diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index e2f89121f..f543375af 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -25,7 +25,8 @@ lib/
 │   ├── network/           # ApiClient + ApiTier + ApiPaths, region failover,
 │   │                      # SSE, ETag cache, meteor delta decode
 │   ├── notifications/     # FCM/APNs + awesome channels, tap routing seam
-│   ├── platform/          # native-first device_info / compass / battery / tier
+│   ├── platform/          # native-first device_info / compass / battery / tier /
+│   │                      # gallery image saver
 │   ├── realtime/          # polling spine (channel/state/clock/staleness/SSE)
 │   ├── settings/          # typed Prefs facade + persisted/ephemeral controllers
 │   ├── storage/           # SQLite stores (ETag cache, network usage)
diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml
index 7bf338d6c..d1c0cd057 100644
--- a/android/app/src/main/AndroidManifest.xml
+++ b/android/app/src/main/AndroidManifest.xml
@@ -21,6 +21,13 @@
          keeps running on aggressive battery managers (safety-app use). -->
     <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
 
+    <!-- Saving the report image (ImageSaverChannel). Android 9 and below write
+         into the public Pictures directory, which needs this grant; Android 10+
+         goes through MediaStore and needs nothing, so the declaration stops at
+         28 rather than asking for storage the app no longer uses. -->
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        android:maxSdkVersion="28"/>
+
     <!-- Bluetooth (meshtastic_flutter / flutter_blue_plus): connect to LoRa
          mesh radios over BLE. The maxSdkVersion=30 pair is the legacy API;
          CONNECT/SCAN cover Android 12+ (runtime permissions, requested by the
diff --git a/android/app/src/main/kotlin/com/exptech/dpip/ImageSaverChannel.kt b/android/app/src/main/kotlin/com/exptech/dpip/ImageSaverChannel.kt
new file mode 100644
index 000000000..c76803973
--- /dev/null
+++ b/android/app/src/main/kotlin/com/exptech/dpip/ImageSaverChannel.kt
@@ -0,0 +1,178 @@
+package com.exptech.dpip
+
+import android.Manifest
+import android.content.ContentValues
+import android.content.Context
+import android.content.pm.PackageManager
+import android.media.MediaScannerConnection
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugin.common.MethodChannel
+import java.io.File
+import java.io.IOException
+
+/**
+ * Saves encoded image bytes into the device's photo library.
+ *
+ * The counterpart of iOS's `ImageSaverPlugin`, and the same channel name and
+ * protocol, so the Dart side is one implementation and the platform is the only
+ * difference. The bytes are the ones the app already fetched (the CWA report
+ * image), so nothing here downloads anything.
+ *
+ * Two paths, because the storage model changed in Android 10:
+ *
+ * - **API 29+** writes through MediaStore with `RELATIVE_PATH`, which needs no
+ *   storage permission at all and lets the gallery index the file itself. The
+ *   row is inserted as `IS_PENDING` and published only once the bytes are
+ *   written, so a camera roll can never pick up a half-written image.
+ * - **API 26–28** writes into the public Pictures directory, which does need
+ *   `WRITE_EXTERNAL_STORAGE` (declared `maxSdkVersion="28"`). Losing that grant
+ *   is reported as `permission_denied` rather than guessed at here: Dart asks
+ *   for the permission and retries once.
+ *
+ * Nothing is overwritten. A name that already exists gets a ` (n)` suffix, the
+ * way a desktop file manager would — saving the same report twice is a normal
+ * thing to do, and silently replacing the first copy is not.
+ */
+class ImageSaverChannel(private val context: Context) :
+    MethodChannel.MethodCallHandler {
+
+    companion object {
+        const val NAME = "com.exptech.dpip/image_saver"
+
+        /** The album the saved pictures land in, shared with iOS's asset album. */
+        private const val ALBUM = "DPIP"
+    }
+
+    override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
+        when (call.method) {
+            "save" -> save(call, result)
+            "status" -> result.success(status())
+            else -> result.notImplemented()
+        }
+    }
+
+    /**
+     * Whether a save can be written right now.
+     *
+     * API 29+ needs no permission (`granted` unconditionally): MediaStore owns
+     * the write, and the manifest caps `WRITE_EXTERNAL_STORAGE` at 28 so asking
+     * on a newer device would be a prompt nobody can grant. Only the legacy
+     * public-directory path reports `denied`, which is what the Dart side turns
+     * into a runtime request.
+     */
+    private fun status(): String =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q ||
+            context.checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) ==
+            PackageManager.PERMISSION_GRANTED
+        ) {
+            "granted"
+        } else {
+            "denied"
+        }
+
+    private fun save(call: MethodCall, result: MethodChannel.Result) {
+        val bytes = call.argument<ByteArray>("bytes")
+        val fileName = call.argument<String>("fileName")
+        val mimeType = call.argument<String>("mimeType") ?: "image/png"
+        if (bytes == null || bytes.isEmpty() || fileName.isNullOrBlank()) {
+            result.error("invalid_args", "bytes and fileName are required", null)
+            return
+        }
+
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                saveToMediaStore(bytes, fileName, mimeType)
+            } else {
+                saveToPicturesDirectory(bytes, fileName, mimeType)
+            }
+            result.success(null)
+        } catch (error: SecurityException) {
+            // The legacy grant, and only that: API 29+ needs no permission, so
+            // reaching this there means something else refused the write.
+            result.error("permission_denied", error.message, null)
+        } catch (error: Exception) {
+            result.error("save_failed", error.message, null)
+        }
+    }
+
+    /** API 29+: one MediaStore row, published after the bytes are written. */
+    private fun saveToMediaStore(bytes: ByteArray, fileName: String, mimeType: String) {
+        val resolver = context.contentResolver
+        val values = ContentValues().apply {
+            put(MediaStore.Images.Media.DISPLAY_NAME, fileName)
+            put(MediaStore.Images.Media.MIME_TYPE, mimeType)
+            put(
+                MediaStore.Images.Media.RELATIVE_PATH,
+                "${Environment.DIRECTORY_PICTURES}/$ALBUM",
+            )
+            put(MediaStore.Images.Media.IS_PENDING, 1)
+        }
+
+        val uri = resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)
+            ?: throw IOException("MediaStore refused the image entry")
+
+        try {
+            val stream = resolver.openOutputStream(uri)
+                ?: throw IOException("MediaStore could not open the image for writing")
+            stream.use { it.write(bytes) }
+        } catch (error: Exception) {
+            // A failed write must not leave a pending row behind: it would be
+            // invisible to the gallery and never cleaned up by it.
+            resolver.delete(uri, null, null)
+            throw error
+        }
+
+        resolver.update(
+            uri,
+            ContentValues().apply { put(MediaStore.Images.Media.IS_PENDING, 0) },
+            null,
+            null,
+        )
+    }
+
+    /** API 26–28: the public Pictures directory, then tell the gallery about it. */
+    private fun saveToPicturesDirectory(bytes: ByteArray, fileName: String, mimeType: String) {
+        if (context.checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) !=
+            PackageManager.PERMISSION_GRANTED
+        ) {
+            throw SecurityException("WRITE_EXTERNAL_STORAGE is not granted")
+        }
+        if (Environment.getExternalStorageState() != Environment.MEDIA_MOUNTED) {
+            throw IOException("External storage is not mounted")
+        }
+
+        val album = File(
+            Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
+            ALBUM,
+        )
+        if (!album.exists() && !album.mkdirs()) {
+            throw IOException("Could not create the $ALBUM album")
+        }
+
+        val file = uniqueFile(album, fileName)
+        file.writeBytes(bytes)
+        // Writes outside MediaStore are invisible until something tells the
+        // gallery to index them; without this the picture exists but no Photos
+        // app lists it.
+        MediaScannerConnection.scanFile(context, arrayOf(file.absolutePath), arrayOf(mimeType), null)
+    }
+
+    /** [fileName] in [directory], or the first `name (n).ext` that is free. */
+    private fun uniqueFile(directory: File, fileName: String): File {
+        val candidate = File(directory, fileName)
+        if (!candidate.exists()) return candidate
+
+        val dot = fileName.lastIndexOf('.')
+        val base = if (dot > 0) fileName.substring(0, dot) else fileName
+        val extension = if (dot > 0) fileName.substring(dot) else ""
+        var index = 1
+        while (true) {
+            val next = File(directory, "$base ($index)$extension")
+            if (!next.exists()) return next
+            index++
+        }
+    }
+}
diff --git a/android/app/src/main/kotlin/com/exptech/dpip/MainActivity.kt b/android/app/src/main/kotlin/com/exptech/dpip/MainActivity.kt
index b07d720a1..91f5c33a4 100644
--- a/android/app/src/main/kotlin/com/exptech/dpip/MainActivity.kt
+++ b/android/app/src/main/kotlin/com/exptech/dpip/MainActivity.kt
@@ -102,6 +102,11 @@ class MainActivity : FlutterActivity() {
         MethodChannel(messenger, NativeLogChannel.NAME)
             .setMethodCallHandler(NativeLogChannel(applicationContext))
 
+        // Saving an image into the gallery. Same channel name and protocol as
+        // iOS's ImageSaverPlugin.
+        MethodChannel(messenger, ImageSaverChannel.NAME)
+            .setMethodCallHandler(ImageSaverChannel(applicationContext))
+
         // The snapshot bridge for the home-screen Widget. Same channel name and
         // protocol as iOS's WidgetSnapshotPlugin, so the Dart writer is one
         // implementation and the platform is the only difference.
diff --git a/ios/Runner.xcodeproj/project.pbxproj b/ios/Runner.xcodeproj/project.pbxproj
index 9e68bd47d..8e1a01a6e 100644
--- a/ios/Runner.xcodeproj/project.pbxproj
+++ b/ios/Runner.xcodeproj/project.pbxproj
@@ -68,6 +68,7 @@
 		LR0S00000000000000000002 /* LocationReportSender.swift in Sources */ = {isa = PBXBuildFile; fileRef = LR0S00000000000000000001 /* LocationReportSender.swift */; };
 		LR0S00000000000000000004 /* LocationReportSenderTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = LR0S00000000000000000003 /* LocationReportSenderTests.swift */; };
 		NL0G00000000000000000002 /* NativeLogPlugin.swift in Sources */ = {isa = PBXBuildFile; fileRef = NL0G00000000000000000001 /* NativeLogPlugin.swift */; };
+		IMSV00000000000000000002 /* ImageSaverPlugin.swift in Sources */ = {isa = PBXBuildFile; fileRef = IMSV00000000000000000001 /* ImageSaverPlugin.swift */; };
 		NL0G00000000000000000004 /* NativeLogTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = NL0G00000000000000000003 /* NativeLogTests.swift */; };
 		NS1K00000000000000000002 /* NotificationSettingsLinkPlugin.swift in Sources */ = {isa = PBXBuildFile; fileRef = NS1K00000000000000000001 /* NotificationSettingsLinkPlugin.swift */; };
 		NSE000000000000000000002 /* NotificationService.appex in Embed Foundation Extensions */ = {isa = PBXBuildFile; fileRef = NSE000000000000000000001 /* NotificationService.appex */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; };
@@ -206,6 +207,7 @@
 		LR0S00000000000000000001 /* LocationReportSender.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LocationReportSender.swift; sourceTree = "<group>"; };
 		LR0S00000000000000000003 /* LocationReportSenderTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LocationReportSenderTests.swift; sourceTree = "<group>"; };
 		NL0G00000000000000000001 /* NativeLogPlugin.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NativeLogPlugin.swift; sourceTree = "<group>"; };
+		IMSV00000000000000000001 /* ImageSaverPlugin.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ImageSaverPlugin.swift; sourceTree = "<group>"; };
 		NL0G00000000000000000003 /* NativeLogTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NativeLogTests.swift; sourceTree = "<group>"; };
 		NS1K00000000000000000001 /* NotificationSettingsLinkPlugin.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NotificationSettingsLinkPlugin.swift; sourceTree = "<group>"; };
 		NSE000000000000000000001 /* NotificationService.appex */ = {isa = PBXFileReference; explicitFileType = "wrapper.app-extension"; includeInIndex = 0; path = NotificationService.appex; sourceTree = BUILT_PRODUCTS_DIR; };
@@ -501,6 +503,7 @@
 				AA0000000000000000000F01 /* ApnsTokenPlugin.swift */,
 				AA0000000000000000000D01 /* DeviceInfoPlugin.swift */,
 				NL0G00000000000000000001 /* NativeLogPlugin.swift */,
+				IMSV00000000000000000001 /* ImageSaverPlugin.swift */,
 				NS1K00000000000000000001 /* NotificationSettingsLinkPlugin.swift */,
 				7884E8672EC3CC0400C636F2 /* SceneDelegate.swift */,
 				74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */,
@@ -869,6 +872,7 @@
 				AA0000000000000000000F02 /* ApnsTokenPlugin.swift in Sources */,
 				AA0000000000000000000D02 /* DeviceInfoPlugin.swift in Sources */,
 				NL0G00000000000000000002 /* NativeLogPlugin.swift in Sources */,
+				IMSV00000000000000000002 /* ImageSaverPlugin.swift in Sources */,
 				NS1K00000000000000000002 /* NotificationSettingsLinkPlugin.swift in Sources */,
 				1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */,
 				7884E8682EC3CC0700C636F2 /* SceneDelegate.swift in Sources */,
diff --git a/ios/Runner/AppDelegate.swift b/ios/Runner/AppDelegate.swift
index 3b6a9b6c1..2b824ceb5 100644
--- a/ios/Runner/AppDelegate.swift
+++ b/ios/Runner/AppDelegate.swift
@@ -56,6 +56,7 @@ import UserNotifications
     MapCachePlugin.register(with: registry.registrar(forPlugin: "MapCachePlugin")!)
     StorageScanPlugin.register(with: registry.registrar(forPlugin: "StorageScanPlugin")!)
     ScreenWakePlugin.register(with: registry.registrar(forPlugin: "ScreenWakePlugin")!)
+    ImageSaverPlugin.register(with: registry.registrar(forPlugin: "ImageSaverPlugin")!)
     ApnsTokenPlugin.register(with: registry.registrar(forPlugin: "ApnsTokenPlugin")!)
     BackgroundLocationPlugin.register(
       with: registry.registrar(forPlugin: "BackgroundLocationPlugin")!)
diff --git a/ios/Runner/ImageSaverPlugin.swift b/ios/Runner/ImageSaverPlugin.swift
new file mode 100644
index 000000000..83d80db9a
--- /dev/null
+++ b/ios/Runner/ImageSaverPlugin.swift
@@ -0,0 +1,100 @@
+import Flutter
+import Photos
+import UIKit
+
+/// Saves encoded image bytes into the photo library — the counterpart of
+/// Android's `ImageSaverChannel`, with the same channel name and protocol.
+///
+/// The bytes are the ones the app already fetched (the CWA report image), so
+/// nothing here downloads anything. Add-only access is what a "save" needs:
+/// the app never reads the library, so iOS shows the narrower grant and never
+/// asks for full photo access.
+///
+/// The asset is created from data rather than from a temporary file: the
+/// filename still reaches the library through `originalFilename`, and no
+/// cleanup path has to be remembered if the write fails halfway.
+public class ImageSaverPlugin: NSObject, FlutterPlugin {
+  public static func register(with registrar: FlutterPluginRegistrar) {
+    let channel = FlutterMethodChannel(
+      name: "com.exptech.dpip/image_saver",
+      binaryMessenger: registrar.messenger())
+    registrar.addMethodCallDelegate(ImageSaverPlugin(), channel: channel)
+  }
+
+  public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+    switch call.method {
+    case "save":
+      save(call.arguments as? [String: Any] ?? [:], result: result)
+    case "status":
+      result(statusName(PHPhotoLibrary.authorizationStatus(for: .addOnly)))
+    case "request":
+      // Asked once by the Dart side before a save; iOS never prompts twice, so
+      // a `denied` answer here is final and the UI offers Settings instead.
+      PHPhotoLibrary.requestAuthorization(for: .addOnly) { status in
+        DispatchQueue.main.async { result(self.statusName(status)) }
+      }
+    default:
+      result(FlutterMethodNotImplemented)
+    }
+  }
+
+  private func statusName(_ status: PHAuthorizationStatus) -> String {
+    switch status {
+    case .authorized, .limited:
+      return "granted"
+    case .denied, .restricted:
+      return "denied"
+    default:
+      return "notDetermined"
+    }
+  }
+
+  private func save(_ args: [String: Any], result: @escaping FlutterResult) {
+    guard
+      let payload = args["bytes"] as? FlutterStandardTypedData,
+      let fileName = args["fileName"] as? String,
+      !fileName.isEmpty
+    else {
+      result(
+        FlutterError(
+          code: "invalid_args", message: "bytes and fileName are required", details: nil))
+      return
+    }
+    let data = payload.data
+
+    PHPhotoLibrary.requestAuthorization(for: .addOnly) { status in
+      guard status == .authorized || status == .limited else {
+        // A refusal is not a failure to report as "try again": the only way
+        // forward is Settings, and the Dart side says exactly that.
+        DispatchQueue.main.async {
+          result(
+            FlutterError(
+              code: "permission_denied", message: "Photo library access was refused",
+              details: nil))
+        }
+        return
+      }
+
+      PHPhotoLibrary.shared().performChanges({
+        let request = PHAssetCreationRequest.forAsset()
+        let options = PHAssetResourceCreationOptions()
+        options.originalFilename = fileName
+        request.addResource(with: .photo, data: data, options: options)
+      }) { success, error in
+        // The completion handler runs off the main thread; Flutter's reply
+        // belongs to the platform thread.
+        DispatchQueue.main.async {
+          if success {
+            result(nil)
+          } else {
+            result(
+              FlutterError(
+                code: "save_failed",
+                message: error?.localizedDescription ?? "The image could not be saved",
+                details: nil))
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/ios/Runner/Info.plist b/ios/Runner/Info.plist
index 122038ae4..a0a33f3e2 100644
--- a/ios/Runner/Info.plist
+++ b/ios/Runner/Info.plist
@@ -59,6 +59,8 @@
 	<string>DPIP 需要在背景持續存取你的位置，即使關閉 App 也能為你所在地推送地震、天氣等災害警報。</string>
 	<key>NSLocationWhenInUseUsageDescription</key>
 	<string>DPIP 需要你的位置，以提供你所在地的地震、天氣等災害警報。</string>
+	<key>NSPhotoLibraryAddUsageDescription</key>
+	<string>DPIP 需要相簿權限，才能將地震報告圖儲存到你的照片。</string>
 	<key>NSUserActivityTypes</key>
 	<array>
 		<string>WeatherWidgetConfigurationIntent</string>
diff --git a/lib/app/shell/main_shell.dart b/lib/app/shell/main_shell.dart
index 2837faa67..7fa1fa4ce 100644
--- a/lib/app/shell/main_shell.dart
+++ b/lib/app/shell/main_shell.dart
@@ -14,6 +14,7 @@ import 'package:dpip/l10n/gen/app_localizations.dart';
 import 'package:dpip/shared/map/base_map.dart';
 import 'package:dpip/shared/map/default_map_layer_ui.dart';
 import 'package:dpip/shared/map/map_camera_handoff.dart';
+import 'package:dpip/shared/map/map_immersive.dart';
 import 'package:dpip/shared/map/map_trace.dart';
 import 'package:dpip/shared/navigation/app_routes.dart';
 import 'package:dpip/shared/navigation/refresh_on_appear.dart';
@@ -40,7 +41,8 @@ class MainShell extends StatefulWidget {
   State<MainShell> createState() => _MainShellState();
 }
 
-class _MainShellState extends State<MainShell> with RouteAware {
+class _MainShellState extends State<MainShell>
+    with RouteAware, SingleTickerProviderStateMixin {
   final int _traceId = nextMapTraceId();
 
   String get _traceScope => 'shell#$_traceId';
@@ -76,6 +78,21 @@ class _MainShellState extends State<MainShell> with RouteAware {
   final ValueNotifier<double> _navDismiss = ValueNotifier(0);
   late final HomeSheetExtent _sheetExtent;
 
+  /// Drives [_navDismiss] on the immersive edge. Home's sheet writes the same
+  /// notifier directly on every drag tick — that is a drag, not a transition —
+  /// so this controller only runs for the map mode's slide.
+  late final AnimationController _navSlide;
+
+  /// Where the bar is heading, kept apart from the animation's current value so
+  /// a rebuild mid-transition does not restart it.
+  double _navTarget = 0;
+
+  /// The map tab's immersive toggle. It dismisses the bar for the same reason
+  /// a full-screen Home sheet does: the map is meant to own the whole screen,
+  /// and a navigation strip over it is the one piece of shell chrome the map
+  /// cannot hide itself.
+  late final MapImmersiveController _mapImmersive;
+
   /// The launch summary's frame window, prerelease builds only. Started here
   /// rather than at the app's first frame because the shell is the first
   /// screen with a map on it — onboarding has none — and it owns the one
@@ -86,8 +103,14 @@ class _MainShellState extends State<MainShell> with RouteAware {
   void initState() {
     super.initState();
     _trace(() => 'init current=${widget.navigationShell.currentIndex}');
+    _navSlide = AnimationController(
+      vsync: this,
+      duration: mapImmersiveTransition,
+    )..addListener(() => _navDismiss.value = _navSlide.value);
     _sheetExtent = context.read<HomeSheetExtent>()
       ..addListener(_syncNavDismiss);
+    _mapImmersive = context.read<MapImmersiveController>()
+      ..addListener(_syncNavDismiss);
     if (isPrereleaseBuild()) {
       // Home (its live map backdrop and the monitor banner) and the map tab
       // are the screens a cheap phone struggles with; a frame drawn over the
@@ -105,13 +128,36 @@ class _MainShellState extends State<MainShell> with RouteAware {
     }
   }
 
-  /// Only Home dismisses the bar; every other tab keeps it (dismiss 0).
+  /// Home's sheet or an immersive map dismisses the bar; every other tab and
+  /// every other map state keeps it (dismiss 0). The immersive edge is
+  /// animated; Home's sheet is a live drag and is followed exactly.
   void _syncNavDismiss() {
-    final dismiss = widget.navigationShell.currentIndex == 0
+    final index = widget.navigationShell.currentIndex;
+    // Both the map tab and the data branch can show a surface that owns the
+    // whole screen (the map, or the earthquake replay nested under data). The
+    // controller is only true while one of them is in the mode; other branches
+    // never hide the bar.
+    final immersiveBranch =
+        index == _mapBranchIndex || index == _dataBranchIndex;
+    final target = index == 0
         ? HomeChrome.navDismiss(_sheetExtent.value)
+        : immersiveBranch && _mapImmersive.value
+        ? 1.0
         : 0.0;
-    if (dismiss == _navDismiss.value) return;
-    _navDismiss.value = dismiss;
+    if (target == _navTarget) return;
+    _navTarget = target;
+    if (index == 0) {
+      _navSlide.stop();
+      _navSlide.value = target;
+      return;
+    }
+    unawaited(
+      _navSlide.animateTo(
+        target,
+        duration: mapImmersiveTransition,
+        curve: mapImmersiveCurve,
+      ),
+    );
   }
 
   @override
@@ -155,6 +201,8 @@ class _MainShellState extends State<MainShell> with RouteAware {
     _startupFrames?.stop();
     if (_shellRoute != null) shellRouteObserver.unsubscribe(this);
     _sheetExtent.removeListener(_syncNavDismiss);
+    _mapImmersive.removeListener(_syncNavDismiss);
+    _navSlide.dispose();
     _navDismiss.dispose();
     _visibleTab.dispose();
     super.dispose();
diff --git a/lib/bootstrap.dart b/lib/bootstrap.dart
index 7d6a89062..3a2d82b15 100644
--- a/lib/bootstrap.dart
+++ b/lib/bootstrap.dart
@@ -78,6 +78,7 @@ import 'package:dpip/features/disaster_map/disaster_map_providers.dart';
 import 'package:dpip/features/earthquake/earthquake_providers.dart';
 import 'package:dpip/features/events/events_providers.dart';
 import 'package:dpip/features/home/home_providers.dart';
+import 'package:dpip/features/map/map_providers.dart';
 import 'package:dpip/features/meshtastic/meshtastic_providers.dart';
 import 'package:dpip/features/notification/notification_providers.dart';
 import 'package:dpip/features/sponsor/sponsor_providers.dart';
@@ -516,6 +517,7 @@ Future<void> bootstrap() async {
         ...earthquakeProviders(deps),
         ...weatherProviders(deps),
         ...disasterMapProviders(deps),
+        ...mapProviders(),
         ...typhoonProviders(deps),
         ...tsunamiProviders(deps),
         ...eventsProviders(deps),
diff --git a/lib/core/error/failure.dart b/lib/core/error/failure.dart
index b1c89ef90..a36b5222f 100644
--- a/lib/core/error/failure.dart
+++ b/lib/core/error/failure.dart
@@ -48,6 +48,29 @@ final class UnexpectedFailure extends Failure {
   const UnexpectedFailure(super.message);
 }
 
+/// An image could not be handed to the platform's photo library.
+///
+/// Its own type because the recovery differs by reason: a refused permission
+/// needs the user in Settings, while a failed write is a plain "try again".
+final class ImageSaveFailure extends Failure {
+  const ImageSaveFailure(this.reason, super.message);
+
+  final ImageSaveFailureReason reason;
+}
+
+/// Why an [ImageSaveFailure] happened.
+enum ImageSaveFailureReason {
+  /// This build has no photo library to save into.
+  unavailable,
+
+  /// The OS refused: photo-library access on iOS, or the legacy storage grant
+  /// on Android 9 and below.
+  permissionDenied,
+
+  /// The write itself failed.
+  failed,
+}
+
 /// A LoRa radio has no free channel slot left for DPIP's own channel.
 ///
 /// Its own type because the recovery is specific and human: DPIP never
diff --git a/lib/core/platform/image_saver.dart b/lib/core/platform/image_saver.dart
new file mode 100644
index 000000000..de24901e7
--- /dev/null
+++ b/lib/core/platform/image_saver.dart
@@ -0,0 +1,274 @@
+import 'dart:io';
+
+import 'package:dpip/core/error/failure.dart';
+import 'package:dpip/core/error/result.dart';
+import 'package:dpip/core/logging/log.dart';
+import 'package:flutter/services.dart';
+import 'package:permission_handler/permission_handler.dart' as ph;
+
+/// Hands encoded image bytes to the platform's own photo library.
+///
+/// The image never crosses this boundary as a path or a widget: the caller owns
+/// the bytes it already has, and the platform owns where a photo lives. Android
+/// writes through MediaStore (or the public Pictures directory on API 26–28),
+/// iOS through `PHPhotoLibrary`, so a saved report appears in the gallery like
+/// any other picture and needs no storage permission from the app's own files.
+abstract interface class ImageSaver {
+  /// Saves [bytes] as a photo named [fileName].
+  ///
+  /// [mimeType] is what the platform records for the file; it must match the
+  /// bytes, or the gallery shows a broken entry rather than the image.
+  ///
+  /// Asks for the photo-library grant first (see [ensurePermission]); a save
+  /// never begins without it.
+  Future<Result<void>> saveToGallery({
+    required Uint8List bytes,
+    required String fileName,
+    String mimeType = 'image/png',
+  });
+
+  /// Obtains the grant [saveToGallery] needs, prompting when the OS still can.
+  ///
+  /// Returned separately so a caller can check before fetching anything, and
+  /// so the UI can tell "the library refused" (Settings is the only way
+  /// forward) apart from a failed write.
+  Future<Result<void>> ensurePermission();
+}
+
+/// The one MethodChannel protocol both platforms speak.
+///
+/// iOS's `ImageSaverPlugin` and Android's `ImageSaverChannel` implement the same
+/// method name, argument keys and error codes, so the platform differences stay
+/// on their own side and the decoding is written once here.
+///
+/// `base` so it can only be extended in this library: the subclasses are the
+/// complete set of platforms this app ships.
+base class _MethodChannelImageSaver implements ImageSaver {
+  _MethodChannelImageSaver(this._channel, this._isSupportedPlatform);
+
+  final MethodChannel _channel;
+  final bool _isSupportedPlatform;
+
+  /// The permission this save needs, asked **before** anything is written.
+  ///
+  /// A save that starts without it is either a system dialog the user sees
+  /// after the fact or a silent failure; asking first is what lets the UI say
+  /// "the photo library refused" and offer Settings instead of a vague error.
+  /// The platform's own check is still the final word — `save` keeps its
+  /// refusal path for the race where the grant is revoked mid-write.
+  @override
+  Future<Result<void>> ensurePermission() async {
+    if (!_isSupportedPlatform) return _unavailable();
+
+    final status = await _channelString('status');
+    switch (status) {
+      case 'granted':
+        return const Ok(null);
+      case 'denied':
+        // iOS never asks twice, so a refusal here is already final.
+        return _permissionDenied();
+      case 'notDetermined':
+        return await _channelString('request') == 'granted'
+            ? const Ok(null)
+            : _permissionDenied();
+      default:
+        // No answer — an engine that never registered the channel, or a future
+        // platform without a status method. `save` still reports unavailable.
+        return const Ok(null);
+    }
+  }
+
+  @override
+  Future<Result<void>> saveToGallery({
+    required Uint8List bytes,
+    required String fileName,
+    String mimeType = 'image/png',
+  }) async {
+    if (!_isSupportedPlatform) return _unavailable();
+
+    final permission = await ensurePermission();
+    if (permission case Err(:final failure)) return Err(failure);
+
+    return _invoke(bytes, fileName, mimeType);
+  }
+
+  Future<String?> _channelString(String method) async {
+    try {
+      return await _channel.invokeMethod<String>(method);
+    } on MissingPluginException {
+      return null;
+    } on PlatformException catch (error, stackTrace) {
+      Log.handle(error, stackTrace, 'image saver $method');
+      return null;
+    }
+  }
+
+  static Result<void> _unavailable() => const Err(
+    ImageSaveFailure(
+      ImageSaveFailureReason.unavailable,
+      'Saving images is unavailable on this platform.',
+    ),
+  );
+
+  static Result<void> _permissionDenied() => const Err(
+    ImageSaveFailure(
+      ImageSaveFailureReason.permissionDenied,
+      'The photo library refused the image.',
+    ),
+  );
+
+  Future<Result<void>> _invoke(
+    Uint8List bytes,
+    String fileName,
+    String mimeType,
+  ) async {
+    try {
+      await _channel.invokeMethod<void>('save', {
+        'bytes': bytes,
+        'fileName': fileName,
+        'mimeType': mimeType,
+      });
+      return const Ok(null);
+    } on MissingPluginException {
+      return const Err(
+        ImageSaveFailure(
+          ImageSaveFailureReason.unavailable,
+          'Saving images is unavailable on this platform.',
+        ),
+      );
+    } on PlatformException catch (error) {
+      final failure = _saveFailure(error);
+      Log.warning('Saving an image failed: ${failure.reason.name}');
+      return Err(failure);
+    } on Object {
+      Log.warning('Saving an image failed unexpectedly');
+      return const Err(
+        ImageSaveFailure(
+          ImageSaveFailureReason.failed,
+          'The image could not be saved.',
+        ),
+      );
+    }
+  }
+
+  static ImageSaveFailure _saveFailure(PlatformException error) {
+    return switch (error.code) {
+      'permission_denied' => const ImageSaveFailure(
+        ImageSaveFailureReason.permissionDenied,
+        'The photo library refused the image.',
+      ),
+      'unsupported' => const ImageSaveFailure(
+        ImageSaveFailureReason.unavailable,
+        'Saving images is unavailable on this platform.',
+      ),
+      _ => const ImageSaveFailure(
+        ImageSaveFailureReason.failed,
+        'The image could not be saved.',
+      ),
+    };
+  }
+}
+
+/// Android implementation — MediaStore, with the legacy public-directory write
+/// on API 26–28 behind `WRITE_EXTERNAL_STORAGE`.
+final class AndroidImageSaver extends _MethodChannelImageSaver {
+  AndroidImageSaver({
+    MethodChannel? channel,
+    bool? isSupportedPlatform,
+    Future<ph.PermissionStatus> Function()? storageStatus,
+    Future<ph.PermissionStatus> Function()? requestStorage,
+  }) : _storageStatus = storageStatus ?? (() => ph.Permission.storage.status),
+       _requestStorage =
+           requestStorage ?? (() => ph.Permission.storage.request()),
+       super(
+         channel ?? const MethodChannel('com.exptech.dpip/image_saver'),
+         isSupportedPlatform ?? Platform.isAndroid,
+       );
+
+  final Future<ph.PermissionStatus> Function() _storageStatus;
+  final Future<ph.PermissionStatus> Function() _requestStorage;
+
+  /// Asks only where Android actually needs a grant.
+  ///
+  /// The native side answers `granted` for API 29+, where MediaStore needs no
+  /// permission at all — asking there would be a prompt nobody can grant, and
+  /// `permission_handler` reports it permanently denied because the manifest
+  /// caps the declaration at API 28.
+  @override
+  Future<Result<void>> ensurePermission() async {
+    if (!_isSupportedPlatform) return super.ensurePermission();
+
+    if (await _channelString('status') == 'granted') return const Ok(null);
+
+    var status = await _storageStatus();
+    if (status.isGranted || status.isLimited) return const Ok(null);
+    if (status.isPermanentlyDenied) {
+      return _MethodChannelImageSaver._permissionDenied();
+    }
+
+    status = await _requestStorage();
+    if (status.isGranted || status.isLimited) return const Ok(null);
+    return _MethodChannelImageSaver._permissionDenied();
+  }
+}
+
+/// iOS implementation — `PHPhotoLibrary` add-only access.
+final class IosImageSaver extends _MethodChannelImageSaver {
+  IosImageSaver({MethodChannel? channel, bool? isSupportedPlatform})
+    : super(
+        channel ?? const MethodChannel('com.exptech.dpip/image_saver'),
+        isSupportedPlatform ?? Platform.isIOS,
+      );
+}
+
+/// The saver for a platform with no photo library.
+///
+/// It exists so callers have no nullable saver and no `Platform` check of their
+/// own; the failure is the same typed one iOS sees when the library refuses.
+final class UnsupportedImageSaver implements ImageSaver {
+  const UnsupportedImageSaver();
+
+  @override
+  Future<Result<void>> ensurePermission() async => const Err(
+    ImageSaveFailure(
+      ImageSaveFailureReason.unavailable,
+      'Saving images is unavailable on this platform.',
+    ),
+  );
+
+  @override
+  Future<Result<void>> saveToGallery({
+    required Uint8List bytes,
+    required String fileName,
+    String mimeType = 'image/png',
+  }) async => const Err(
+    ImageSaveFailure(
+      ImageSaveFailureReason.unavailable,
+      'Saving images is unavailable on this platform.',
+    ),
+  );
+}
+
+/// The saver for the platform this build is running on.
+///
+/// [isIOS] and [isAndroid] exist so the selection itself can be tested: `dart:io`
+/// `Platform` answers for the machine the test runs on, which is neither of the
+/// two platforms this app ships, so a test could otherwise only ever see the
+/// unsupported saver. Production passes neither.
+ImageSaver createImageSaver({
+  bool? isIOS,
+  bool? isAndroid,
+  Future<ph.PermissionStatus> Function()? storageStatus,
+  Future<ph.PermissionStatus> Function()? requestStorage,
+}) {
+  final ios = isIOS ?? Platform.isIOS;
+  final android = isAndroid ?? Platform.isAndroid;
+  if (ios) return IosImageSaver();
+  if (android) {
+    return AndroidImageSaver(
+      storageStatus: storageStatus,
+      requestStorage: requestStorage,
+    );
+  }
+  return const UnsupportedImageSaver();
+}
diff --git a/lib/features/earthquake/presentation/pages/report_detail_page.dart b/lib/features/earthquake/presentation/pages/report_detail_page.dart
index 65157178d..3c4cbaa09 100644
--- a/lib/features/earthquake/presentation/pages/report_detail_page.dart
+++ b/lib/features/earthquake/presentation/pages/report_detail_page.dart
@@ -15,6 +15,8 @@ import 'package:dpip/core/geo/town_directory.dart';
 import 'package:dpip/core/logging/log.dart';
 import 'package:dpip/core/models/lat_lng.dart' as geo;
 import 'package:dpip/core/network/api_client.dart';
+import 'package:dpip/core/permissions/system_settings.dart';
+import 'package:dpip/core/platform/image_saver.dart';
 import 'package:dpip/core/realtime/app_time.dart';
 import 'package:dpip/core/settings/home_area.dart';
 import 'package:dpip/core/settings/region_store.dart';
@@ -30,6 +32,7 @@ import 'package:dpip/shared/map/basemap_overlay_sync.dart';
 import 'package:dpip/shared/map/camera_fit.dart';
 import 'package:dpip/shared/map/map_compass.dart';
 import 'package:dpip/shared/map/map_gsi_overlay.dart';
+import 'package:dpip/shared/map/map_image_density.dart';
 import 'package:dpip/shared/map/map_style.dart';
 import 'package:dpip/shared/map/map_town_labels.dart';
 import 'package:dpip/shared/navigation/app_routes.dart';
@@ -61,11 +64,18 @@ import 'package:url_launcher/url_launcher.dart';
 /// [_sheetExpanded] toggles which one, so expanding the sheet hides the
 /// floating button instead of stacking both.
 class ReportDetailPage extends StatefulWidget {
-  const ReportDetailPage({super.key, required this.reportId});
+  const ReportDetailPage({super.key, required this.reportId, this.imageSaver});
 
   /// The report id (e.g. `115053-2026-0731-005836`), from the route's `:id`.
   final String reportId;
 
+  /// Saves the report image; null means the platform's own saver.
+  ///
+  /// A test seam, not a product switch: `dart:io`'s `Platform` answers for the
+  /// machine the test runs on, so a widget test could otherwise only ever see
+  /// the unsupported saver and prove nothing about the button.
+  final ImageSaver? imageSaver;
+
   @override
   State<ReportDetailPage> createState() => _ReportDetailPageState();
 }
@@ -73,6 +83,10 @@ class ReportDetailPage extends StatefulWidget {
 class _ReportDetailPageState extends State<ReportDetailPage> {
   final ValueNotifier<bool> _sheetExpanded = ValueNotifier(false);
 
+  /// Resolved once: the platform saver opens no resource until it is used, and
+  /// rebuilding the card must not replace the object under it.
+  late final ImageSaver _imageSaver = widget.imageSaver ?? createImageSaver();
+
   /// Guards the bounce below — the error builder runs on every rebuild, and a
   /// second `pop` would take the list away too.
   bool _leaving = false;
@@ -124,6 +138,7 @@ class _ReportDetailPageState extends State<ReportDetailPage> {
               builder: (context, report) => _ReportMapDetail(
                 report: report,
                 sheetExpanded: _sheetExpanded,
+                imageSaver: _imageSaver,
               ),
               error: (context, failure, retry) {
                 if (failure is NotFoundFailure) {
@@ -247,10 +262,18 @@ List<_IntensityGroup> _buildIntensityGroups(EarthquakeReport report) {
 /// The map surface: epicentre + per-town intensity dots, framed to the
 /// report's extent, with [_ReportSheet] docked at the bottom.
 class _ReportMapDetail extends StatefulWidget {
-  const _ReportMapDetail({required this.report, required this.sheetExpanded});
+  const _ReportMapDetail({
+    required this.report,
+    required this.sheetExpanded,
+    required this.imageSaver,
+  });
 
   final EarthquakeReport report;
 
+  /// Hands [ReportDetailPage.imageSaver] down to the sheet's report-image card
+  /// — the widget that owns the save button.
+  final ImageSaver imageSaver;
+
   /// Set by [_ReportSheet] as it's dragged — drives the page's floating back
   /// button's visibility (see [ReportDetailPage]).
   final ValueNotifier<bool> sheetExpanded;
@@ -267,15 +290,15 @@ class _ReportMapDetailState extends State<_ReportMapDetail> {
   /// 0.2, 15 → 0.6): those source PNGs render at native (device-pixel) size,
   /// so on a modern 3x display that old scale is only ~20 logical px — this
   /// page needs the marker legible at a glance, so it's sized up accordingly.
-  static const List<Object> _iconSizeExpression = [
-    'interpolate',
-    ['linear'],
-    ['zoom'],
-    5,
-    0.75,
-    15,
-    1.7,
-  ];
+  ///
+  /// [intensityIconSizeCurve] also folds in [mapIconDensityFactor], because
+  /// Android's `addImage` pins the bitmap to density 160: without it the same
+  /// markers come out three times larger there than on a 3x iPhone.
+  List<Object> get _iconSizeExpression => intensityIconSizeCurve(
+    mapIconDensityFactor(
+      devicePixelRatio: MediaQuery.devicePixelRatioOf(context),
+    ),
+  );
 
   MapLibreMapController? _controller;
   bool _iconsLoaded = false;
@@ -426,8 +449,8 @@ class _ReportMapDetailState extends State<_ReportMapDetail> {
       await controller.addSymbolLayer(
         _sourceId,
         _symbolLayerId,
-        const SymbolLayerProperties(
-          iconImage: ['get', 'icon'],
+        SymbolLayerProperties(
+          iconImage: const ['get', 'icon'],
           iconSize: _iconSizeExpression,
           iconAllowOverlap: true,
           iconIgnorePlacement: true,
@@ -529,6 +552,7 @@ class _ReportMapDetailState extends State<_ReportMapDetail> {
             child: _ReportSheet(
               report: widget.report,
               expandedNotifier: widget.sheetExpanded,
+              saver: widget.imageSaver,
             ),
           ),
           // Base-map options (OSM detailed map / terrain relief / township
@@ -577,7 +601,11 @@ class _ReportMapDetailState extends State<_ReportMapDetail> {
 /// 詳細資訊 + 各地震度 + report-image content under a pinned "地震報告" header
 /// that stays fixed while that content scrolls.
 class _ReportSheet extends StatefulWidget {
-  const _ReportSheet({required this.report, required this.expandedNotifier});
+  const _ReportSheet({
+    required this.report,
+    required this.expandedNotifier,
+    required this.saver,
+  });
 
   final EarthquakeReport report;
 
@@ -585,6 +613,9 @@ class _ReportSheet extends StatefulWidget {
   /// hide its floating back button while the sheet's own header has one.
   final ValueNotifier<bool> expandedNotifier;
 
+  /// Where the report image goes when its save button is tapped.
+  final ImageSaver saver;
+
   /// Collapsed height — sized to the compact summary card.
   static const double peek = 0.32;
 
@@ -759,7 +790,7 @@ class _ReportSheetState extends State<_ReportSheet> {
           _LocalIntensitySection(report: report),
           if (report.list.isNotEmpty) _AreaIntensitySection(report: report),
           SectionHeader(l10n.reportDetailImage),
-          _ReportImageCard(report: report),
+          _ReportImageCard(report: report, saver: widget.saver),
         ],
       ),
     );
@@ -1665,11 +1696,17 @@ class _TownChip extends StatelessWidget {
 /// caches the picture like any map tile — `Image.network` would hit Flutter's
 /// image pipeline, which has no SQLite store behind it and refetches on every
 /// visit.
+/// The save action sits on the image itself rather than beside the section
+/// header: it only means anything once the bytes are here, and a header action
+/// would have to explain why it is disabled while the picture loads.
 class _ReportImageCard extends StatefulWidget {
-  const _ReportImageCard({required this.report});
+  const _ReportImageCard({required this.report, required this.saver});
 
   final EarthquakeReport report;
 
+  /// Where the picture goes when the save button is tapped.
+  final ImageSaver saver;
+
   @override
   State<_ReportImageCard> createState() => _ReportImageCardState();
 }
@@ -1685,6 +1722,53 @@ class _ReportImageCardState extends State<_ReportImageCard> {
   /// image itself sizes to its own natural proportions once loaded.
   static const double _placeholderHeight = 200;
 
+  /// True while the platform is writing; the button shows a spinner and
+  /// ignores a second tap rather than stacking saves of the same picture.
+  bool _saving = false;
+
+  /// Unique per report and recognisable in a gallery: the same report saved
+  /// twice gets `(1)`, `(2)`… from the platform, never an overwrite.
+  String get _fileName => 'dpip-earthquake-${widget.report.id}.png';
+
+  Future<void> _save(Uint8List bytes) async {
+    if (_saving) return;
+    setState(() => _saving = true);
+
+    final result = await widget.saver.saveToGallery(
+      bytes: bytes,
+      fileName: _fileName,
+    );
+    if (!mounted) return;
+    setState(() => _saving = false);
+
+    final l10n = AppLocalizations.of(context);
+    final refused =
+        result.failureOrNull is ImageSaveFailure &&
+        (result.failureOrNull! as ImageSaveFailure).reason ==
+            ImageSaveFailureReason.permissionDenied;
+    final message = result.when(
+      ok: (_) => l10n.reportDetailImageSaved,
+      // A refusal is not "try again": the only way forward is Settings, so the
+      // two failures must not share a sentence — nor the same snackbar.
+      err: (_) => refused
+          ? l10n.reportDetailImageSavePermissionDenied
+          : l10n.reportDetailImageSaveFailed,
+    );
+    ScaffoldMessenger.of(context)
+      ..hideCurrentSnackBar()
+      ..showSnackBar(
+        SnackBar(
+          content: Text(message),
+          action: refused
+              ? SnackBarAction(
+                  label: l10n.permissionOpenSettings,
+                  onPressed: openAppSettingsPage,
+                )
+              : null,
+        ),
+      );
+  }
+
   @override
   Widget build(BuildContext context) {
     final l10n = AppLocalizations.of(context);
@@ -1722,23 +1806,41 @@ class _ReportImageCardState extends State<_ReportImageCard> {
         }
         return ClipRRect(
           borderRadius: AppRadius.medium,
-          child: Image.memory(
-            snapshot.data!,
-            // No forced aspect ratio / BoxFit.cover — the report image's real
-            // proportions vary per event, so this sizes to the image's own
-            // natural aspect ratio at full width instead of cropping or padding.
-            width: double.infinity,
-            fit: BoxFit.contain,
-            errorBuilder: (context, error, stackTrace) => Container(
-              height: _placeholderHeight,
-              width: double.infinity,
-              color: colors.surfaceContainer,
-              alignment: Alignment.center,
-              child: Text(
-                l10n.reportDetailImageUnavailable,
-                style: TextStyle(color: colors.onSurfaceVariant),
+          child: Stack(
+            alignment: Alignment.topRight,
+            children: [
+              Image.memory(
+                snapshot.data!,
+                // No forced aspect ratio / BoxFit.cover — the report image's real
+                // proportions vary per event, so this sizes to the image's own
+                // natural aspect ratio at full width instead of cropping or padding.
+                width: double.infinity,
+                fit: BoxFit.contain,
+                errorBuilder: (context, error, stackTrace) => Container(
+                  height: _placeholderHeight,
+                  width: double.infinity,
+                  color: colors.surfaceContainer,
+                  alignment: Alignment.center,
+                  child: Text(
+                    l10n.reportDetailImageUnavailable,
+                    style: TextStyle(color: colors.onSurfaceVariant),
+                  ),
+                ),
               ),
-            ),
+              Padding(
+                padding: const EdgeInsets.all(AppSpacing.sm),
+                child: IconButton.filledTonal(
+                  onPressed: _saving ? null : () => _save(snapshot.data!),
+                  tooltip: l10n.reportDetailImageSave,
+                  icon: _saving
+                      ? const SizedBox.square(
+                          dimension: 18,
+                          child: CircularProgressIndicator(strokeWidth: 2),
+                        )
+                      : const Icon(Icons.download_rounded),
+                ),
+              ),
+            ],
           ),
         );
       },
diff --git a/lib/features/earthquake/presentation/pages/report_replay_page.dart b/lib/features/earthquake/presentation/pages/report_replay_page.dart
index c553f3db2..29aec1495 100644
--- a/lib/features/earthquake/presentation/pages/report_replay_page.dart
+++ b/lib/features/earthquake/presentation/pages/report_replay_page.dart
@@ -60,6 +60,8 @@ import 'package:dpip/shared/map/camera_fit.dart';
 import 'package:dpip/shared/map/geo_circle.dart';
 import 'package:dpip/shared/map/wavefront_cadence.dart';
 import 'package:dpip/shared/map/map_compass.dart';
+import 'package:dpip/shared/map/map_immersive.dart';
+import 'package:dpip/shared/map/map_immersive_chrome.dart';
 import 'package:dpip/shared/map/map_gsi_overlay.dart';
 import 'package:dpip/shared/map/map_town_labels.dart';
 import 'package:dpip/shared/map/map_style.dart'
@@ -118,6 +120,18 @@ class _ReportReplayPageState extends State<ReportReplayPage> {
   /// advances it through the alert set (modulo the count in the builder).
   int _eewIndex = 0;
 
+  /// The app-wide immersive toggle, borrowed from the map tab for the length
+  /// of this route. The shell draws the bottom nav bar for every branch,
+  /// including this nested one, so a page-local flag could hide the replay's
+  /// own chrome while leaving the bar on screen. The controller is reset on
+  /// entry and exit so the map tab and the replay never inherit each other's
+  /// mode.
+  late final MapImmersiveController _immersive;
+
+  void _onImmersiveChanged() {
+    if (mounted) setState(() {});
+  }
+
   /// Speaks each new report's estimated intensity while the replay runs, the
   /// same way the live monitor does — a replay that stayed silent would not be
   /// a replay of what the user would have heard.
@@ -153,6 +167,10 @@ class _ReportReplayPageState extends State<ReportReplayPage> {
       cwaOnly: () => cwaOnly.enabled,
     )..start();
     _session.eew.addListener(_syncAnnouncement);
+    _immersive = context.read<MapImmersiveController>()
+      ..addListener(_onImmersiveChanged);
+    // A replay opens with its controls, whatever the map tab was left in.
+    if (_immersive.value) _immersive.exit();
     _startTicker();
   }
 
@@ -281,166 +299,208 @@ class _ReportReplayPageState extends State<ReportReplayPage> {
     _speechSettings?.removeListener(_syncAnnouncement);
     _announcement?.dispose();
     _clockSecond.dispose();
+    _immersive.removeListener(_onImmersiveChanged);
+    if (_immersive.value) _immersive.exit();
     _session.dispose();
     super.dispose();
   }
 
   @override
   Widget build(BuildContext context) {
+    final immersive = _immersive.value;
     return ActiveWhileVisible(
       tabIndex: ReportListPage.tabIndex,
       onActiveChanged: _applyActivity,
-      child: Scaffold(
-        body: Stack(
-          children: [
-            Positioned.fill(
-              child: _ReplayMap(
-                stationRepository: context.read<TremStationRepository>(),
-                travelTimeTable: context.read<Future<SeismicTravelTimeTable>>(),
-                boxGrid: context.read<Future<RtsBoxGrid>>(),
-                rts: _session.rts,
-                alerts: _alerts,
-                eew: _session.eew,
-                tick: _tick,
-                clock: _session.clock,
-                eewIndex: _eewIndex,
+      child: PopScope(
+        // While immersive the first back gesture belongs to the mode, not to
+        // the route: a user who hid the back chip must not have to find the
+        // exit chip to avoid leaving the replay.
+        canPop: !immersive,
+        onPopInvokedWithResult: (didPop, _) {
+          if (!didPop) _immersive.exit();
+        },
+        child: Scaffold(
+          body: Stack(
+            children: [
+              Positioned.fill(
+                child: _ReplayMap(
+                  stationRepository: context.read<TremStationRepository>(),
+                  travelTimeTable: context
+                      .read<Future<SeismicTravelTimeTable>>(),
+                  boxGrid: context.read<Future<RtsBoxGrid>>(),
+                  rts: _session.rts,
+                  alerts: _alerts,
+                  eew: _session.eew,
+                  tick: _tick,
+                  clock: _session.clock,
+                  eewIndex: _eewIndex,
+                  immersive: immersive,
+                  onImmersive: _immersive.enter,
+                ),
               ),
-            ),
-            Positioned(
-              top: 0,
-              left: 0,
-              child: SafeArea(
-                child: Padding(
-                  padding: const EdgeInsets.all(AppSpacing.lg),
-                  child: Column(
-                    crossAxisAlignment: CrossAxisAlignment.start,
-                    children: [
-                      // Back and legend share one row, and both are the
-                      // shared [MapChipButton] so the whole top edge — back,
-                      // legend, and the base-map chip on the right — is one
-                      // height. A bare [IconButton] back was the tallest thing
-                      // on screen (its padded tap target is 48px) and read as
-                      // a different app's control sitting next to ours.
-                      Row(
-                        mainAxisSize: MainAxisSize.min,
+              Positioned(
+                top: 0,
+                left: 0,
+                child: MapImmersiveChrome(
+                  hidden: immersive,
+                  child: SafeArea(
+                    child: Padding(
+                      padding: const EdgeInsets.all(AppSpacing.lg),
+                      child: Column(
                         crossAxisAlignment: CrossAxisAlignment.start,
                         children: [
-                          MapChipButton(
-                            icon: Icons.arrow_back,
-                            tooltip: MaterialLocalizations.of(context)
-                                .backButtonTooltip,
-                            active: false,
-                            onTap: () => context.pop(),
+                          // Back and legend share one row, and both are the
+                          // shared [MapChipButton] so the whole top edge — back,
+                          // legend, and the base-map chip on the right — is one
+                          // height. A bare [IconButton] back was the tallest thing
+                          // on screen (its padded tap target is 48px) and read as
+                          // a different app's control sitting next to ours.
+                          Row(
+                            mainAxisSize: MainAxisSize.min,
+                            crossAxisAlignment: CrossAxisAlignment.start,
+                            children: [
+                              MapChipButton(
+                                icon: Icons.arrow_back,
+                                tooltip: MaterialLocalizations.of(context)
+                                    .backButtonTooltip,
+                                active: false,
+                                onTap: () => context.pop(),
+                              ),
+                              const SizedBox(width: AppSpacing.sm),
+                              // The replay surface is the 強震監視器 frozen in time —
+                              // the same intensity legend the live monitor carries,
+                              // switching to the EEW felt-scale while an alert is up
+                              // (the legacy monitor did exactly this on active EEW).
+                              //
+                              // Collapsible, and collapsed to a chip to start with,
+                              // exactly as [MapScaffold] mounts every layer's legend:
+                              // this page is a full-screen map too, and an
+                              // eleven-row scale pinned open covers the north-west
+                              // corner of the island for the whole replay. The wrap
+                              // sits *outside* the mode swap on purpose — an alert
+                              // arriving mid-replay changes the scale being shown,
+                              // not whether the user asked to see it.
+                              CollapsibleMapLegend(
+                                legend: ListenableBuilder(
+                                  listenable: _session.eew,
+                                  builder: (context, _) {
+                                    final alerts =
+                                        _session.eew.alerts.uncancelled;
+                                    final maxEewLevel = alerts.isEmpty
+                                        ? null
+                                        : alerts
+                                              .map(
+                                                (alert) =>
+                                                    alert.info.max.clamp(0, 9),
+                                              )
+                                              .reduce((a, b) => a > b ? a : b);
+                                    return MapLegendCard(
+                                      child: IntensityLegend(
+                                        mode: alerts.isNotEmpty
+                                            ? IntensityLegendMode.eew
+                                            : IntensityLegendMode.rts,
+                                        maxEewLevel: maxEewLevel,
+                                      ),
+                                    );
+                                  },
+                                ),
+                              ),
+                            ],
                           ),
-                          const SizedBox(width: AppSpacing.sm),
-                          // The replay surface is the 強震監視器 frozen in time —
-                          // the same intensity legend the live monitor carries,
-                          // switching to the EEW felt-scale while an alert is up
-                          // (the legacy monitor did exactly this on active EEW).
-                          //
-                          // Collapsible, and collapsed to a chip to start with,
-                          // exactly as [MapScaffold] mounts every layer's legend:
-                          // this page is a full-screen map too, and an
-                          // eleven-row scale pinned open covers the north-west
-                          // corner of the island for the whole replay. The wrap
-                          // sits *outside* the mode swap on purpose — an alert
-                          // arriving mid-replay changes the scale being shown,
-                          // not whether the user asked to see it.
-                          CollapsibleMapLegend(
-                            legend: ListenableBuilder(
-                              listenable: _session.eew,
-                              builder: (context, _) {
-                                final alerts = _session.eew.alerts.uncancelled;
-                                final maxEewLevel = alerts.isEmpty
-                                    ? null
-                                    : alerts
-                                          .map(
-                                            (alert) =>
-                                                alert.info.max.clamp(0, 9),
-                                          )
-                                          .reduce((a, b) => a > b ? a : b);
-                                return MapLegendCard(
-                                  child: IntensityLegend(
-                                    mode: alerts.isNotEmpty
-                                        ? IntensityLegendMode.eew
-                                        : IntensityLegendMode.rts,
-                                    maxEewLevel: maxEewLevel,
-                                  ),
-                                );
-                              },
-                            ),
+                          const SizedBox(height: AppSpacing.md),
+                          ListenableBuilder(
+                            listenable: _session.rts,
+                            builder: (context, _) {
+                              final towns = context.read<TownDirectory>();
+                              return IntensityRankingCard(
+                                entries: [
+                                  for (final row in _alerts.ranking(
+                                    towns.byCode,
+                                  ))
+                                    (name: row.name, level: row.level),
+                                ],
+                              );
+                            },
                           ),
                         ],
                       ),
-                      const SizedBox(height: AppSpacing.md),
-                      ListenableBuilder(
-                        listenable: _session.rts,
-                        builder: (context, _) {
-                          final towns = context.read<TownDirectory>();
-                          return IntensityRankingCard(
-                            entries: [
-                              for (final row in _alerts.ranking(towns.byCode))
-                                (name: row.name, level: row.level),
-                            ],
-                          );
-                        },
-                      ),
-                    ],
+                    ),
                   ),
                 ),
               ),
-            ),
-            Positioned(
-              bottom: 0,
-              left: 0,
-              right: 0,
-              child: SafeArea(
-                top: false,
-                child: Padding(
-                  padding: const EdgeInsets.all(AppSpacing.lg),
-                  child: Column(
-                    mainAxisSize: MainAxisSize.min,
-                    crossAxisAlignment: CrossAxisAlignment.stretch,
-                    children: [
-                      ListenableBuilder(
-                        listenable: _session.eew,
-                        builder: (context, _) {
-                          final alerts = _session.eew.alerts;
-                          if (alerts.isEmpty) return const SizedBox.shrink();
-                          // One card at a time — tapping cycles through the
-                          // active alerts (parallel earthquakes, overlapping
-                          // reports) instead of stacking every one on screen.
-                          // The index is clamped by modulo, so a report leaving
-                          // the active set mid-replay can't point past the list.
-                          final index = _eewIndex % alerts.length;
-                          final eew = alerts[index];
-                          return _EewAlertCard(
-                            eew: eew,
-                            clock: () => _session.clock.now(),
-                            position: index + 1,
-                            count: alerts.length,
-                            onTap: alerts.length > 1
-                                ? () => setState(
-                                    () => _eewIndex =
-                                        (_eewIndex + 1) % alerts.length,
-                                  )
-                                : null,
-                          );
-                        },
-                      ),
-                      const SizedBox(height: AppSpacing.sm),
-                      _ReplayStatusBar(
-                        clock: _session.clock,
-                        second: _clockSecond,
-                        rts: _session.rts,
-                        eew: _session.eew,
+              Positioned(
+                bottom: 0,
+                left: 0,
+                right: 0,
+                child: MapImmersiveChrome(
+                  hidden: immersive,
+                  slide: const Offset(0, 0.25),
+                  child: SafeArea(
+                    top: false,
+                    child: Padding(
+                      padding: const EdgeInsets.all(AppSpacing.lg),
+                      child: Column(
+                        mainAxisSize: MainAxisSize.min,
+                        crossAxisAlignment: CrossAxisAlignment.stretch,
+                        children: [
+                          ListenableBuilder(
+                            listenable: _session.eew,
+                            builder: (context, _) {
+                              final alerts = _session.eew.alerts;
+                              if (alerts.isEmpty) {
+                                return const SizedBox.shrink();
+                              }
+                              // One card at a time — tapping cycles through the
+                              // active alerts (parallel earthquakes, overlapping
+                              // reports) instead of stacking every one on screen.
+                              // The index is clamped by modulo, so a report leaving
+                              // the active set mid-replay can't point past the list.
+                              final index = _eewIndex % alerts.length;
+                              final eew = alerts[index];
+                              return _EewAlertCard(
+                                eew: eew,
+                                clock: () => _session.clock.now(),
+                                position: index + 1,
+                                count: alerts.length,
+                                onTap: alerts.length > 1
+                                    ? () => setState(
+                                        () => _eewIndex =
+                                            (_eewIndex + 1) % alerts.length,
+                                      )
+                                    : null,
+                              );
+                            },
+                          ),
+                          const SizedBox(height: AppSpacing.sm),
+                          _ReplayStatusBar(
+                            clock: _session.clock,
+                            second: _clockSecond,
+                            rts: _session.rts,
+                            eew: _session.eew,
+                          ),
+                        ],
                       ),
-                    ],
+                    ),
                   ),
                 ),
               ),
-            ),
-          ],
+              // The one control left in immersive mode, above every card the
+              // replay can draw — and in the same corner the map tab puts it.
+              Positioned(
+                top: 0,
+                right: 0,
+                child: SafeArea(
+                  child: Padding(
+                    padding: const EdgeInsets.all(AppSpacing.lg),
+                    child: MapImmersiveExitChip(
+                      immersive: immersive,
+                      onExit: _immersive.exit,
+                    ),
+                  ),
+                ),
+              ),
+            ],
+          ),
         ),
       ),
     );
@@ -464,6 +524,8 @@ class _ReplayMap extends StatefulWidget {
     required this.tick,
     required this.clock,
     required this.eewIndex,
+    required this.immersive,
+    required this.onImmersive,
   });
 
   final TremStationRepository stationRepository;
@@ -490,6 +552,13 @@ class _ReplayMap extends StatefulWidget {
   /// showing, not always the newest.
   final int eewIndex;
 
+  /// Whether the replay is in immersive mode. The map hides its own top-right
+  /// chrome with the rest of the page's.
+  final bool immersive;
+
+  /// Enters the mode from the map's own chip.
+  final VoidCallback onImmersive;
+
   @override
   State<_ReplayMap> createState() => _ReplayMapState();
 }
@@ -1386,28 +1455,45 @@ class _ReplayMapState extends State<_ReplayMap> {
               ),
             ),
             // Base-map options (OSM detailed map / terrain relief / township
-            // names) above the compass — the same chrome the 強震監視器 carries in
-            // the map tab, persisted to the shared settings store. No sheet
-            // here, so the controls stay up for the whole replay.
+            // names) and the immersive toggle, above the compass — the same
+            // chrome the 強震監視器 carries in the map tab, persisted to the
+            // shared settings store. No sheet here, so the controls stay up
+            // for the whole replay.
             Positioned(
               top: 0,
               right: 0,
-              child: SafeArea(
-                child: Padding(
-                  padding: const EdgeInsets.all(AppSpacing.lg),
-                  child: Column(
-                    mainAxisSize: MainAxisSize.min,
-                    crossAxisAlignment: CrossAxisAlignment.end,
-                    children: [
-                      MapBasemapMenu(
-                        showTownLabels: _showTownLabels,
-                        onShowTownLabelsChanged: _setShowTownLabels,
-                        showTerrain: _showTerrain,
-                        onShowTerrainChanged: _setShowTerrain,
-                      ),
-                      const SizedBox(height: AppSpacing.sm),
-                      MapCompass(bearing: _bearing, onPressed: _resetNorth),
-                    ],
+              child: MapImmersiveChrome(
+                hidden: widget.immersive,
+                child: SafeArea(
+                  child: Padding(
+                    padding: const EdgeInsets.all(AppSpacing.lg),
+                    child: Column(
+                      mainAxisSize: MainAxisSize.min,
+                      crossAxisAlignment: CrossAxisAlignment.end,
+                      children: [
+                        Row(
+                          mainAxisSize: MainAxisSize.min,
+                          children: [
+                            MapChipButton(
+                              icon: Icons.fullscreen,
+                              tooltip: AppLocalizations.of(context)
+                                  .mapImmersive,
+                              active: false,
+                              onTap: widget.onImmersive,
+                            ),
+                            const SizedBox(width: AppSpacing.sm),
+                            MapBasemapMenu(
+                              showTownLabels: _showTownLabels,
+                              onShowTownLabelsChanged: _setShowTownLabels,
+                              showTerrain: _showTerrain,
+                              onShowTerrainChanged: _setShowTerrain,
+                            ),
+                          ],
+                        ),
+                        const SizedBox(height: AppSpacing.sm),
+                        MapCompass(bearing: _bearing, onPressed: _resetNorth),
+                      ],
+                    ),
                   ),
                 ),
               ),
diff --git a/lib/features/map/map_providers.dart b/lib/features/map/map_providers.dart
new file mode 100644
index 000000000..bcd16739a
--- /dev/null
+++ b/lib/features/map/map_providers.dart
@@ -0,0 +1,16 @@
+/// Provider wiring for the map tab.
+library;
+
+import 'package:dpip/shared/map/map_immersive.dart';
+import 'package:provider/provider.dart';
+import 'package:provider/single_child_widget.dart';
+
+/// Map-tab view state shared with the app shell.
+///
+/// Only one map surface is on screen at a time, so its immersive toggle is one
+/// app-wide value rather than state inside the scaffold: `MainShell` has to
+/// read the same value to hide the bottom navigation, and it sits above every
+/// branch in the tree.
+List<SingleChildWidget> mapProviders() => [
+  ChangeNotifierProvider(create: (_) => MapImmersiveController()),
+];
diff --git a/lib/l10n/app_en.arb b/lib/l10n/app_en.arb
index d25d04983..bc46cc52a 100644
--- a/lib/l10n/app_en.arb
+++ b/lib/l10n/app_en.arb
@@ -1416,6 +1416,14 @@
   },
   "homeForecastUnavailable": "Select a township to see the forecast",
   "mapLayers": "Layers",
+  "mapImmersive": "Immersive map",
+  "mapImmersiveExit": "Exit immersive mode",
+  "@mapImmersive": {
+    "description": "Layer sheet entry that hides the map controls and the navigation bar"
+  },
+  "@mapImmersiveExit": {
+    "description": "Tooltip for the floating button that leaves immersive map mode"
+  },
   "@homeRainTrendHeavyStopping": {
     "description": "Home rain trend subtitle: heavy rain forecast to stop partway through the hour",
     "placeholders": {
@@ -1427,6 +1435,9 @@
   "@mapTownLabels": {
     "description": "Map setting: show township-name labels when the map is zoomed in"
   },
+  "@mapSettingsPanel": {
+    "description": "Tooltip for the button that opens the map settings panel"
+  },
   "@weatherModeRain": {
     "description": "Weather animation forced to rain"
   },
@@ -1638,6 +1649,22 @@
     "description": "Rainfall accumulation since local midnight (API now)"
   },
   "reportDetailImageUnavailable": "Report image not available",
+  "@reportDetailImageSave": {
+    "description": "Save button on the CWA report image"
+  },
+  "@reportDetailImageSaved": {
+    "description": "Confirmation after the report image was saved to the photo library"
+  },
+  "@reportDetailImageSaveFailed": {
+    "description": "Shown when saving the report image failed"
+  },
+  "@reportDetailImageSavePermissionDenied": {
+    "description": "Shown when the photo library refused the report image"
+  },
+  "reportDetailImageSave": "Save image",
+  "reportDetailImageSaved": "Saved to your photos",
+  "reportDetailImageSaveFailed": "Couldn't save the image",
+  "reportDetailImageSavePermissionDenied": "Allow photo access to save the image",
   "@weatherRankingMergeTo": {
     "description": "Label before township/county merge chips on ranking"
   },
@@ -2996,6 +3023,7 @@
   "mapOsmSectionRoadsAndBuildings": "Roads & buildings",
   "mapOsmSectionLabelsAndPlaces": "Labels & places",
   "mapTownLabels": "Township names",
+  "mapSettingsPanel": "Map settings panel",
   "@typhoonOverlayWarningTooltip": {
     "description": "Tooltip for the warning-areas overlay toggle"
   },
diff --git a/lib/l10n/app_fil.arb b/lib/l10n/app_fil.arb
index 1992d4ab9..ff68d843a 100644
--- a/lib/l10n/app_fil.arb
+++ b/lib/l10n/app_fil.arb
@@ -494,6 +494,8 @@
   "moreGithub": "ExpTech GitHub",
   "homeForecastUnavailable": "Pumili ng bayan para makita ang forecast",
   "mapLayers": "Mga Layer",
+  "mapImmersive": "Immersive na mapa",
+  "mapImmersiveExit": "Lumabas sa immersive mode",
   "meshtasticHardware": "Hardware",
   "languageSettings": "Wika",
   "@moonNextFullMoon": {
@@ -563,6 +565,10 @@
   "reportFilterOrderAsc": "Pataas",
   "reportFilterApply": "I-apply",
   "reportDetailImageUnavailable": "Wala pang available na larawan ng ulat",
+  "reportDetailImageSave": "I-save ang larawan",
+  "reportDetailImageSaved": "Nai-save sa mga larawan",
+  "reportDetailImageSaveFailed": "Hindi ma-save ang larawan",
+  "reportDetailImageSavePermissionDenied": "Payagan ang access sa mga larawan upang ma-save",
   "@weatherModeSand": {
     "description": "Label for the weatherModeSand option in the experimental backdrop settings."
   },
@@ -1183,6 +1189,7 @@
   "mapOsmSectionRoadsAndBuildings": "Mga kalsada at gusali",
   "mapOsmSectionLabelsAndPlaces": "Mga label at lugar",
   "mapTownLabels": "Mga pangalan ng bayan",
+  "mapSettingsPanel": "Panel ng mga setting ng mapa",
   "notifySetFailed": "Hindi ma-save ang setting. Pakisubukan muli.",
   "meshtasticDisconnect": "I-disconnect",
   "meshtasticUndecoded": "Hindi nade-decrypt",
diff --git a/lib/l10n/app_id.arb b/lib/l10n/app_id.arb
index 363d4e242..0c052456e 100644
--- a/lib/l10n/app_id.arb
+++ b/lib/l10n/app_id.arb
@@ -494,6 +494,8 @@
   "moreGithub": "ExpTech GitHub",
   "homeForecastUnavailable": "Pilih wilayah untuk melihat prakiraan",
   "mapLayers": "Lapisan",
+  "mapImmersive": "Peta imersif",
+  "mapImmersiveExit": "Keluar dari mode imersif",
   "meshtasticHardware": "Perangkat keras",
   "languageSettings": "Bahasa",
   "@moonNextFullMoon": {
@@ -563,6 +565,10 @@
   "reportFilterOrderAsc": "Menaik",
   "reportFilterApply": "Terapkan",
   "reportDetailImageUnavailable": "Gambar laporan belum tersedia",
+  "reportDetailImageSave": "Simpan gambar",
+  "reportDetailImageSaved": "Tersimpan di foto",
+  "reportDetailImageSaveFailed": "Gambar gagal disimpan",
+  "reportDetailImageSavePermissionDenied": "Izinkan akses foto untuk menyimpan gambar",
   "@weatherModeSand": {
     "description": "Label for the weatherModeSand option in the experimental backdrop settings."
   },
@@ -1183,6 +1189,7 @@
   "mapOsmSectionRoadsAndBuildings": "Jalan & bangunan",
   "mapOsmSectionLabelsAndPlaces": "Label & tempat",
   "mapTownLabels": "Nama kecamatan",
+  "mapSettingsPanel": "Panel pengaturan peta",
   "notifySetFailed": "Tidak dapat menyimpan pengaturan. Silakan coba lagi.",
   "meshtasticDisconnect": "Putuskan",
   "meshtasticUndecoded": "Belum didekripsi",
diff --git a/lib/l10n/app_ja.arb b/lib/l10n/app_ja.arb
index ccf68e033..4e117c3b7 100644
--- a/lib/l10n/app_ja.arb
+++ b/lib/l10n/app_ja.arb
@@ -494,6 +494,8 @@
   "moreGithub": "ExpTech GitHub",
   "homeForecastUnavailable": "地域を選ぶと予報を表示します",
   "mapLayers": "レイヤー",
+  "mapImmersive": "没入型マップ",
+  "mapImmersiveExit": "全画面表示を終了",
   "meshtasticHardware": "ハードウェア",
   "languageSettings": "言語設定",
   "@moonNextFullMoon": {
@@ -563,6 +565,10 @@
   "reportFilterOrderAsc": "昇順",
   "reportFilterApply": "適用",
   "reportDetailImageUnavailable": "レポート画像はまだありません",
+  "reportDetailImageSave": "画像を保存",
+  "reportDetailImageSaved": "写真に保存しました",
+  "reportDetailImageSaveFailed": "画像を保存できませんでした",
+  "reportDetailImageSavePermissionDenied": "写真へのアクセスを許可すると保存できます",
   "@weatherModeSand": {
     "description": "Label for the weatherModeSand option in the experimental backdrop settings."
   },
@@ -1183,6 +1189,7 @@
   "mapOsmSectionRoadsAndBuildings": "道路と建物",
   "mapOsmSectionLabelsAndPlaces": "ラベルと場所",
   "mapTownLabels": "郷鎮名",
+  "mapSettingsPanel": "地図設定パネル",
   "notifySetFailed": "設定を保存できませんでした。もう一度お試しください。",
   "meshtasticDisconnect": "切断",
   "meshtasticUndecoded": "復号されていません",
diff --git a/lib/l10n/app_ko.arb b/lib/l10n/app_ko.arb
index 3dc77a78d..429a2d82d 100644
--- a/lib/l10n/app_ko.arb
+++ b/lib/l10n/app_ko.arb
@@ -494,6 +494,8 @@
   "moreGithub": "ExpTech GitHub",
   "homeForecastUnavailable": "지역을 선택하면 예보를 볼 수 있습니다",
   "mapLayers": "레이어",
+  "mapImmersive": "몰입형 지도",
+  "mapImmersiveExit": "몰입 모드 종료",
   "meshtasticHardware": "하드웨어",
   "languageSettings": "언어",
   "@moonNextFullMoon": {
@@ -563,6 +565,10 @@
   "reportFilterOrderAsc": "오름차순",
   "reportFilterApply": "적용",
   "reportDetailImageUnavailable": "보고서 이미지가 아직 없습니다",
+  "reportDetailImageSave": "이미지 저장",
+  "reportDetailImageSaved": "사진에 저장했습니다",
+  "reportDetailImageSaveFailed": "이미지를 저장하지 못했습니다",
+  "reportDetailImageSavePermissionDenied": "사진 접근을 허용하면 저장할 수 있습니다",
   "@weatherModeSand": {
     "description": "Label for the weatherModeSand option in the experimental backdrop settings."
   },
@@ -1183,6 +1189,7 @@
   "mapOsmSectionRoadsAndBuildings": "도로 및 건물",
   "mapOsmSectionLabelsAndPlaces": "레이블 및 장소",
   "mapTownLabels": "읍면동 이름",
+  "mapSettingsPanel": "지도 설정 패널",
   "notifySetFailed": "설정을 저장하지 못했습니다. 다시 시도해 주세요.",
   "meshtasticDisconnect": "연결 해제",
   "meshtasticUndecoded": "복호화되지 않음",
diff --git a/lib/l10n/app_th.arb b/lib/l10n/app_th.arb
index 3e9b8d828..8007efe82 100644
--- a/lib/l10n/app_th.arb
+++ b/lib/l10n/app_th.arb
@@ -494,6 +494,8 @@
   "moreGithub": "ExpTech GitHub",
   "homeForecastUnavailable": "เลือกพื้นที่เพื่อดูพยากรณ์",
   "mapLayers": "ชั้นข้อมูล",
+  "mapImmersive": "แผนที่เต็มจอ",
+  "mapImmersiveExit": "ออกจากโหมดเต็มจอ",
   "meshtasticHardware": "ฮาร์ดแวร์",
   "languageSettings": "ภาษา",
   "@moonNextFullMoon": {
@@ -563,6 +565,10 @@
   "reportFilterOrderAsc": "น้อย→มาก",
   "reportFilterApply": "ใช้",
   "reportDetailImageUnavailable": "ยังไม่มีภาพรายงาน",
+  "reportDetailImageSave": "บันทึกรูปภาพ",
+  "reportDetailImageSaved": "บันทึกไปยังรูปภาพแล้ว",
+  "reportDetailImageSaveFailed": "บันทึกรูปภาพไม่สำเร็จ",
+  "reportDetailImageSavePermissionDenied": "อนุญาตการเข้าถึงรูปภาพเพื่อบันทึก",
   "@weatherModeSand": {
     "description": "Label for the weatherModeSand option in the experimental backdrop settings."
   },
@@ -1183,6 +1189,7 @@
   "mapOsmSectionRoadsAndBuildings": "ถนนและอาคาร",
   "mapOsmSectionLabelsAndPlaces": "ป้ายชื่อและสถานที่",
   "mapTownLabels": "ชื่อตำบล",
+  "mapSettingsPanel": "แผงการตั้งค่าแผนที่",
   "notifySetFailed": "ไม่สามารถบันทึกการตั้งค่าได้ โปรดลองอีกครั้ง",
   "meshtasticDisconnect": "ตัดการเชื่อมต่อ",
   "meshtasticUndecoded": "ไม่ได้ถอดรหัส",
diff --git a/lib/l10n/app_vi.arb b/lib/l10n/app_vi.arb
index ff4215d0f..f23316852 100644
--- a/lib/l10n/app_vi.arb
+++ b/lib/l10n/app_vi.arb
@@ -494,6 +494,8 @@
   "moreGithub": "ExpTech GitHub",
   "homeForecastUnavailable": "Chọn khu vực để xem dự báo",
   "mapLayers": "Lớp bản đồ",
+  "mapImmersive": "Bản đồ toàn màn hình",
+  "mapImmersiveExit": "Thoát chế độ toàn màn hình",
   "meshtasticHardware": "Phần cứng",
   "languageSettings": "Ngôn ngữ",
   "@moonNextFullMoon": {
@@ -563,6 +565,10 @@
   "reportFilterOrderAsc": "Tăng dần",
   "reportFilterApply": "Áp dụng",
   "reportDetailImageUnavailable": "Hình ảnh báo cáo chưa có sẵn",
+  "reportDetailImageSave": "Lưu ảnh",
+  "reportDetailImageSaved": "Đã lưu vào ảnh",
+  "reportDetailImageSaveFailed": "Không lưu được ảnh",
+  "reportDetailImageSavePermissionDenied": "Cho phép truy cập ảnh để lưu",
   "@weatherModeSand": {
     "description": "Label for the weatherModeSand option in the experimental backdrop settings."
   },
@@ -1183,6 +1189,7 @@
   "mapOsmSectionRoadsAndBuildings": "Đường & tòa nhà",
   "mapOsmSectionLabelsAndPlaces": "Nhãn & địa điểm",
   "mapTownLabels": "Tên hương trấn",
+  "mapSettingsPanel": "Bảng cài đặt bản đồ",
   "notifySetFailed": "Không thể lưu cài đặt. Vui lòng thử lại.",
   "meshtasticDisconnect": "Ngắt kết nối",
   "meshtasticUndecoded": "Chưa giải mã",
diff --git a/lib/l10n/app_yue.arb b/lib/l10n/app_yue.arb
index 6e56e73e8..3c5b0f10f 100644
--- a/lib/l10n/app_yue.arb
+++ b/lib/l10n/app_yue.arb
@@ -496,6 +496,8 @@
   "moreGithub": "ExpTech GitHub",
   "homeForecastUnavailable": "選擇地區後可查看預報",
   "mapLayers": "圖層",
+  "mapImmersive": "沉浸式地圖",
+  "mapImmersiveExit": "結束沉浸式",
   "meshtasticHardware": "硬體",
   "languageSettings": "語言設定",
   "@moonNextFullMoon": {
@@ -565,6 +567,10 @@
   "reportFilterOrderAsc": "升序",
   "reportFilterApply": "套用",
   "reportDetailImageUnavailable": "報告圖尚未提供",
+  "reportDetailImageSave": "儲存圖片",
+  "reportDetailImageSaved": "已儲存到相簿",
+  "reportDetailImageSaveFailed": "儲存圖片失敗",
+  "reportDetailImageSavePermissionDenied": "要相簿權限先可以儲存圖片",
   "@weatherModeSand": {
     "description": "Label for the weatherModeSand option in the experimental backdrop settings."
   },
@@ -1183,6 +1189,7 @@
   "mapOsmSectionRoadsAndBuildings": "道路同建物",
   "mapOsmSectionLabelsAndPlaces": "地名同標示",
   "mapTownLabels": "鄉鎮名稱",
+  "mapSettingsPanel": "地圖設定面板",
   "notifySetFailed": "設定失敗,請稍後再試。",
   "meshtasticDisconnect": "斷線",
   "meshtasticUndecoded": "冇辦法解密",
diff --git a/lib/l10n/app_zh.arb b/lib/l10n/app_zh.arb
index 4cdc24d8e..e63be9f62 100644
--- a/lib/l10n/app_zh.arb
+++ b/lib/l10n/app_zh.arb
@@ -494,6 +494,8 @@
   "moreGithub": "ExpTech GitHub",
   "homeForecastUnavailable": "選擇鄉鎮後可查看預報",
   "mapLayers": "圖層",
+  "mapImmersive": "沉浸式地圖",
+  "mapImmersiveExit": "結束沉浸式",
   "meshtasticHardware": "硬體",
   "languageSettings": "語言設定",
   "@moonNextFullMoon": {
@@ -563,6 +565,10 @@
   "reportFilterOrderAsc": "升序",
   "reportFilterApply": "套用",
   "reportDetailImageUnavailable": "報告圖尚未提供",
+  "reportDetailImageSave": "儲存圖片",
+  "reportDetailImageSaved": "已儲存到相簿",
+  "reportDetailImageSaveFailed": "儲存圖片失敗",
+  "reportDetailImageSavePermissionDenied": "需要相簿權限才能儲存圖片",
   "@weatherModeSand": {
     "description": "Label for the weatherModeSand option in the experimental backdrop settings."
   },
@@ -1175,6 +1181,7 @@
   "mapOsmSectionRoadsAndBuildings": "道路與建物",
   "mapOsmSectionLabelsAndPlaces": "地名與標示",
   "mapTownLabels": "鄉鎮名稱",
+  "mapSettingsPanel": "地圖設定面板",
   "notifySetFailed": "設定失敗，請稍後再試。",
   "meshtasticDisconnect": "斷線",
   "meshtasticUndecoded": "無法解密",
diff --git a/lib/l10n/app_zh_Hans.arb b/lib/l10n/app_zh_Hans.arb
index d374dbd61..795ca33d7 100644
--- a/lib/l10n/app_zh_Hans.arb
+++ b/lib/l10n/app_zh_Hans.arb
@@ -494,6 +494,8 @@
   "moreGithub": "ExpTech GitHub",
   "homeForecastUnavailable": "选择乡镇后可查看预报",
   "mapLayers": "图层",
+  "mapImmersive": "沉浸式地图",
+  "mapImmersiveExit": "退出沉浸模式",
   "meshtasticHardware": "硬件",
   "languageSettings": "语言设置",
   "@moonNextFullMoon": {
@@ -563,6 +565,10 @@
   "reportFilterOrderAsc": "升序",
   "reportFilterApply": "应用",
   "reportDetailImageUnavailable": "报告图尚未提供",
+  "reportDetailImageSave": "保存图片",
+  "reportDetailImageSaved": "已保存到相册",
+  "reportDetailImageSaveFailed": "保存图片失败",
+  "reportDetailImageSavePermissionDenied": "需要相册权限才能保存图片",
   "@weatherModeSand": {
     "description": "Label for the weatherModeSand option in the experimental backdrop settings."
   },
@@ -1183,6 +1189,7 @@
   "mapOsmSectionRoadsAndBuildings": "道路与建筑",
   "mapOsmSectionLabelsAndPlaces": "地名与标注",
   "mapTownLabels": "乡镇名称",
+  "mapSettingsPanel": "地图设置面板",
   "notifySetFailed": "设置失败，请稍后再试。",
   "meshtasticDisconnect": "斷線",
   "meshtasticUndecoded": "无法解密",
diff --git a/lib/l10n/app_zh_Hant_HK.arb b/lib/l10n/app_zh_Hant_HK.arb
index 4d1e807e8..cf5ed12aa 100644
--- a/lib/l10n/app_zh_Hant_HK.arb
+++ b/lib/l10n/app_zh_Hant_HK.arb
@@ -494,6 +494,8 @@
   "moreGithub": "ExpTech GitHub",
   "homeForecastUnavailable": "選擇地區後可查看預報",
   "mapLayers": "圖層",
+  "mapImmersive": "沉浸式地圖",
+  "mapImmersiveExit": "結束沉浸式",
   "meshtasticHardware": "硬體",
   "languageSettings": "語言設定",
   "@moonNextFullMoon": {
@@ -563,6 +565,10 @@
   "reportFilterOrderAsc": "升序",
   "reportFilterApply": "套用",
   "reportDetailImageUnavailable": "報告圖尚未提供",
+  "reportDetailImageSave": "儲存圖片",
+  "reportDetailImageSaved": "已儲存到相簿",
+  "reportDetailImageSaveFailed": "儲存圖片失敗",
+  "reportDetailImageSavePermissionDenied": "需要相簿權限才能儲存圖片",
   "@weatherModeSand": {
     "description": "Label for the weatherModeSand option in the experimental backdrop settings."
   },
@@ -1183,6 +1189,7 @@
   "mapOsmSectionRoadsAndBuildings": "道路與建物",
   "mapOsmSectionLabelsAndPlaces": "地名與標示",
   "mapTownLabels": "鄉鎮名稱",
+  "mapSettingsPanel": "地圖設定面板",
   "notifySetFailed": "設定失敗,請稍後再試。",
   "meshtasticDisconnect": "斷線",
   "meshtasticUndecoded": "無法解密",
diff --git a/lib/l10n/app_zh_TW.arb b/lib/l10n/app_zh_TW.arb
index 3d2463435..87b70e985 100644
--- a/lib/l10n/app_zh_TW.arb
+++ b/lib/l10n/app_zh_TW.arb
@@ -494,6 +494,8 @@
   "moreGithub": "ExpTech GitHub",
   "homeForecastUnavailable": "選擇鄉鎮後可查看預報",
   "mapLayers": "圖層",
+  "mapImmersive": "沉浸式地圖",
+  "mapImmersiveExit": "結束沉浸式",
   "meshtasticHardware": "硬體",
   "languageSettings": "語言設定",
   "@moonNextFullMoon": {
@@ -563,6 +565,10 @@
   "reportFilterOrderAsc": "升序",
   "reportFilterApply": "套用",
   "reportDetailImageUnavailable": "報告圖尚未提供",
+  "reportDetailImageSave": "儲存圖片",
+  "reportDetailImageSaved": "已儲存到相簿",
+  "reportDetailImageSaveFailed": "儲存圖片失敗",
+  "reportDetailImageSavePermissionDenied": "需要相簿權限才能儲存圖片",
   "@weatherModeSand": {
     "description": "Label for the weatherModeSand option in the experimental backdrop settings."
   },
@@ -1183,6 +1189,7 @@
   "mapOsmSectionRoadsAndBuildings": "道路與建物",
   "mapOsmSectionLabelsAndPlaces": "地名與標示",
   "mapTownLabels": "鄉鎮名稱",
+  "mapSettingsPanel": "地圖設定面板",
   "notifySetFailed": "設定失敗，請稍後再試。",
   "meshtasticDisconnect": "斷線",
   "meshtasticUndecoded": "無法解密",
diff --git a/lib/l10n/gen/app_localizations.dart b/lib/l10n/gen/app_localizations.dart
index cd838b19e..164e7da89 100644
--- a/lib/l10n/gen/app_localizations.dart
+++ b/lib/l10n/gen/app_localizations.dart
@@ -2064,6 +2064,18 @@ abstract class AppLocalizations {
   /// **'Layers'**
   String get mapLayers;
 
+  /// Layer sheet entry that hides the map controls and the navigation bar
+  ///
+  /// In en, this message translates to:
+  /// **'Immersive map'**
+  String get mapImmersive;
+
+  /// Tooltip for the floating button that leaves immersive map mode
+  ///
+  /// In en, this message translates to:
+  /// **'Exit immersive mode'**
+  String get mapImmersiveExit;
+
   /// Board model
   ///
   /// In en, this message translates to:
@@ -2382,6 +2394,30 @@ abstract class AppLocalizations {
   /// **'Report image not available'**
   String get reportDetailImageUnavailable;
 
+  /// Save button on the CWA report image
+  ///
+  /// In en, this message translates to:
+  /// **'Save image'**
+  String get reportDetailImageSave;
+
+  /// Confirmation after the report image was saved to the photo library
+  ///
+  /// In en, this message translates to:
+  /// **'Saved to your photos'**
+  String get reportDetailImageSaved;
+
+  /// Shown when saving the report image failed
+  ///
+  /// In en, this message translates to:
+  /// **'Couldn\'t save the image'**
+  String get reportDetailImageSaveFailed;
+
+  /// Shown when the photo library refused the report image
+  ///
+  /// In en, this message translates to:
+  /// **'Allow photo access to save the image'**
+  String get reportDetailImageSavePermissionDenied;
+
   /// Button that opens the RTS/EEW replay starting from this report's origin time
   ///
   /// In en, this message translates to:
@@ -4800,6 +4836,12 @@ abstract class AppLocalizations {
   /// **'Township names'**
   String get mapTownLabels;
 
+  /// Tooltip for the button that opens the map settings panel
+  ///
+  /// In en, this message translates to:
+  /// **'Map settings panel'**
+  String get mapSettingsPanel;
+
   /// Snackbar shown when saving a notification channel fails
   ///
   /// In en, this message translates to:
diff --git a/lib/l10n/gen/app_localizations_en.dart b/lib/l10n/gen/app_localizations_en.dart
index 0b0e36a9f..70f79803b 100644
--- a/lib/l10n/gen/app_localizations_en.dart
+++ b/lib/l10n/gen/app_localizations_en.dart
@@ -1084,6 +1084,12 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get mapLayers => 'Layers';
 
+  @override
+  String get mapImmersive => 'Immersive map';
+
+  @override
+  String get mapImmersiveExit => 'Exit immersive mode';
+
   @override
   String get meshtasticHardware => 'Hardware';
 
@@ -1254,6 +1260,19 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get reportDetailImageUnavailable => 'Report image not available';
 
+  @override
+  String get reportDetailImageSave => 'Save image';
+
+  @override
+  String get reportDetailImageSaved => 'Saved to your photos';
+
+  @override
+  String get reportDetailImageSaveFailed => 'Couldn\'t save the image';
+
+  @override
+  String get reportDetailImageSavePermissionDenied =>
+      'Allow photo access to save the image';
+
   @override
   String get reportDetailReplay => 'Replay';
 
@@ -2554,6 +2573,9 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get mapTownLabels => 'Township names';
 
+  @override
+  String get mapSettingsPanel => 'Map settings panel';
+
   @override
   String get notifySetFailed => 'Couldn\'t save the setting. Please try again.';
 
diff --git a/lib/l10n/gen/app_localizations_fil.dart b/lib/l10n/gen/app_localizations_fil.dart
index 5a9248eb9..e7b0dd490 100644
--- a/lib/l10n/gen/app_localizations_fil.dart
+++ b/lib/l10n/gen/app_localizations_fil.dart
@@ -1093,6 +1093,12 @@ class AppLocalizationsFil extends AppLocalizations {
   @override
   String get mapLayers => 'Mga Layer';
 
+  @override
+  String get mapImmersive => 'Immersive na mapa';
+
+  @override
+  String get mapImmersiveExit => 'Lumabas sa immersive mode';
+
   @override
   String get meshtasticHardware => 'Hardware';
 
@@ -1264,6 +1270,19 @@ class AppLocalizationsFil extends AppLocalizations {
   String get reportDetailImageUnavailable =>
       'Wala pang available na larawan ng ulat';
 
+  @override
+  String get reportDetailImageSave => 'I-save ang larawan';
+
+  @override
+  String get reportDetailImageSaved => 'Nai-save sa mga larawan';
+
+  @override
+  String get reportDetailImageSaveFailed => 'Hindi ma-save ang larawan';
+
+  @override
+  String get reportDetailImageSavePermissionDenied =>
+      'Payagan ang access sa mga larawan upang ma-save';
+
   @override
   String get reportDetailReplay => 'I-replay';
 
@@ -2570,6 +2589,9 @@ class AppLocalizationsFil extends AppLocalizations {
   @override
   String get mapTownLabels => 'Mga pangalan ng bayan';
 
+  @override
+  String get mapSettingsPanel => 'Panel ng mga setting ng mapa';
+
   @override
   String get notifySetFailed => 'Hindi ma-save ang setting. Pakisubukan muli.';
 
diff --git a/lib/l10n/gen/app_localizations_id.dart b/lib/l10n/gen/app_localizations_id.dart
index 500d4e64a..1f72cee00 100644
--- a/lib/l10n/gen/app_localizations_id.dart
+++ b/lib/l10n/gen/app_localizations_id.dart
@@ -1085,6 +1085,12 @@ class AppLocalizationsId extends AppLocalizations {
   @override
   String get mapLayers => 'Lapisan';
 
+  @override
+  String get mapImmersive => 'Peta imersif';
+
+  @override
+  String get mapImmersiveExit => 'Keluar dari mode imersif';
+
   @override
   String get meshtasticHardware => 'Perangkat keras';
 
@@ -1255,6 +1261,19 @@ class AppLocalizationsId extends AppLocalizations {
   @override
   String get reportDetailImageUnavailable => 'Gambar laporan belum tersedia';
 
+  @override
+  String get reportDetailImageSave => 'Simpan gambar';
+
+  @override
+  String get reportDetailImageSaved => 'Tersimpan di foto';
+
+  @override
+  String get reportDetailImageSaveFailed => 'Gambar gagal disimpan';
+
+  @override
+  String get reportDetailImageSavePermissionDenied =>
+      'Izinkan akses foto untuk menyimpan gambar';
+
   @override
   String get reportDetailReplay => 'Putar ulang';
 
@@ -2560,6 +2579,9 @@ class AppLocalizationsId extends AppLocalizations {
   @override
   String get mapTownLabels => 'Nama kecamatan';
 
+  @override
+  String get mapSettingsPanel => 'Panel pengaturan peta';
+
   @override
   String get notifySetFailed =>
       'Tidak dapat menyimpan pengaturan. Silakan coba lagi.';
diff --git a/lib/l10n/gen/app_localizations_ja.dart b/lib/l10n/gen/app_localizations_ja.dart
index 578f2ffe8..b22d3b7ce 100644
--- a/lib/l10n/gen/app_localizations_ja.dart
+++ b/lib/l10n/gen/app_localizations_ja.dart
@@ -1063,6 +1063,12 @@ class AppLocalizationsJa extends AppLocalizations {
   @override
   String get mapLayers => 'レイヤー';
 
+  @override
+  String get mapImmersive => '没入型マップ';
+
+  @override
+  String get mapImmersiveExit => '全画面表示を終了';
+
   @override
   String get meshtasticHardware => 'ハードウェア';
 
@@ -1231,6 +1237,18 @@ class AppLocalizationsJa extends AppLocalizations {
   @override
   String get reportDetailImageUnavailable => 'レポート画像はまだありません';
 
+  @override
+  String get reportDetailImageSave => '画像を保存';
+
+  @override
+  String get reportDetailImageSaved => '写真に保存しました';
+
+  @override
+  String get reportDetailImageSaveFailed => '画像を保存できませんでした';
+
+  @override
+  String get reportDetailImageSavePermissionDenied => '写真へのアクセスを許可すると保存できます';
+
   @override
   String get reportDetailReplay => 'リプレイ';
 
@@ -2509,6 +2527,9 @@ class AppLocalizationsJa extends AppLocalizations {
   @override
   String get mapTownLabels => '郷鎮名';
 
+  @override
+  String get mapSettingsPanel => '地図設定パネル';
+
   @override
   String get notifySetFailed => '設定を保存できませんでした。もう一度お試しください。';
 
diff --git a/lib/l10n/gen/app_localizations_ko.dart b/lib/l10n/gen/app_localizations_ko.dart
index c52d95a72..1a6ed7d6d 100644
--- a/lib/l10n/gen/app_localizations_ko.dart
+++ b/lib/l10n/gen/app_localizations_ko.dart
@@ -1063,6 +1063,12 @@ class AppLocalizationsKo extends AppLocalizations {
   @override
   String get mapLayers => '레이어';
 
+  @override
+  String get mapImmersive => '몰입형 지도';
+
+  @override
+  String get mapImmersiveExit => '몰입 모드 종료';
+
   @override
   String get meshtasticHardware => '하드웨어';
 
@@ -1231,6 +1237,18 @@ class AppLocalizationsKo extends AppLocalizations {
   @override
   String get reportDetailImageUnavailable => '보고서 이미지가 아직 없습니다';
 
+  @override
+  String get reportDetailImageSave => '이미지 저장';
+
+  @override
+  String get reportDetailImageSaved => '사진에 저장했습니다';
+
+  @override
+  String get reportDetailImageSaveFailed => '이미지를 저장하지 못했습니다';
+
+  @override
+  String get reportDetailImageSavePermissionDenied => '사진 접근을 허용하면 저장할 수 있습니다';
+
   @override
   String get reportDetailReplay => '다시 보기';
 
@@ -2510,6 +2528,9 @@ class AppLocalizationsKo extends AppLocalizations {
   @override
   String get mapTownLabels => '읍면동 이름';
 
+  @override
+  String get mapSettingsPanel => '지도 설정 패널';
+
   @override
   String get notifySetFailed => '설정을 저장하지 못했습니다. 다시 시도해 주세요.';
 
diff --git a/lib/l10n/gen/app_localizations_th.dart b/lib/l10n/gen/app_localizations_th.dart
index dcb9d2621..69e86626c 100644
--- a/lib/l10n/gen/app_localizations_th.dart
+++ b/lib/l10n/gen/app_localizations_th.dart
@@ -1079,6 +1079,12 @@ class AppLocalizationsTh extends AppLocalizations {
   @override
   String get mapLayers => 'ชั้นข้อมูล';
 
+  @override
+  String get mapImmersive => 'แผนที่เต็มจอ';
+
+  @override
+  String get mapImmersiveExit => 'ออกจากโหมดเต็มจอ';
+
   @override
   String get meshtasticHardware => 'ฮาร์ดแวร์';
 
@@ -1249,6 +1255,19 @@ class AppLocalizationsTh extends AppLocalizations {
   @override
   String get reportDetailImageUnavailable => 'ยังไม่มีภาพรายงาน';
 
+  @override
+  String get reportDetailImageSave => 'บันทึกรูปภาพ';
+
+  @override
+  String get reportDetailImageSaved => 'บันทึกไปยังรูปภาพแล้ว';
+
+  @override
+  String get reportDetailImageSaveFailed => 'บันทึกรูปภาพไม่สำเร็จ';
+
+  @override
+  String get reportDetailImageSavePermissionDenied =>
+      'อนุญาตการเข้าถึงรูปภาพเพื่อบันทึก';
+
   @override
   String get reportDetailReplay => 'เล่นย้อนหลัง';
 
@@ -2546,6 +2565,9 @@ class AppLocalizationsTh extends AppLocalizations {
   @override
   String get mapTownLabels => 'ชื่อตำบล';
 
+  @override
+  String get mapSettingsPanel => 'แผงการตั้งค่าแผนที่';
+
   @override
   String get notifySetFailed => 'ไม่สามารถบันทึกการตั้งค่าได้ โปรดลองอีกครั้ง';
 
diff --git a/lib/l10n/gen/app_localizations_vi.dart b/lib/l10n/gen/app_localizations_vi.dart
index ef8494130..78a044195 100644
--- a/lib/l10n/gen/app_localizations_vi.dart
+++ b/lib/l10n/gen/app_localizations_vi.dart
@@ -1082,6 +1082,12 @@ class AppLocalizationsVi extends AppLocalizations {
   @override
   String get mapLayers => 'Lớp bản đồ';
 
+  @override
+  String get mapImmersive => 'Bản đồ toàn màn hình';
+
+  @override
+  String get mapImmersiveExit => 'Thoát chế độ toàn màn hình';
+
   @override
   String get meshtasticHardware => 'Phần cứng';
 
@@ -1252,6 +1258,19 @@ class AppLocalizationsVi extends AppLocalizations {
   @override
   String get reportDetailImageUnavailable => 'Hình ảnh báo cáo chưa có sẵn';
 
+  @override
+  String get reportDetailImageSave => 'Lưu ảnh';
+
+  @override
+  String get reportDetailImageSaved => 'Đã lưu vào ảnh';
+
+  @override
+  String get reportDetailImageSaveFailed => 'Không lưu được ảnh';
+
+  @override
+  String get reportDetailImageSavePermissionDenied =>
+      'Cho phép truy cập ảnh để lưu';
+
   @override
   String get reportDetailReplay => 'Phát lại';
 
@@ -2555,6 +2574,9 @@ class AppLocalizationsVi extends AppLocalizations {
   @override
   String get mapTownLabels => 'Tên hương trấn';
 
+  @override
+  String get mapSettingsPanel => 'Bảng cài đặt bản đồ';
+
   @override
   String get notifySetFailed => 'Không thể lưu cài đặt. Vui lòng thử lại.';
 
diff --git a/lib/l10n/gen/app_localizations_yue.dart b/lib/l10n/gen/app_localizations_yue.dart
index 5b65778af..b4a8b7a4a 100644
--- a/lib/l10n/gen/app_localizations_yue.dart
+++ b/lib/l10n/gen/app_localizations_yue.dart
@@ -1056,6 +1056,12 @@ class AppLocalizationsYue extends AppLocalizations {
   @override
   String get mapLayers => '圖層';
 
+  @override
+  String get mapImmersive => '沉浸式地圖';
+
+  @override
+  String get mapImmersiveExit => '結束沉浸式';
+
   @override
   String get meshtasticHardware => '硬體';
 
@@ -1222,6 +1228,18 @@ class AppLocalizationsYue extends AppLocalizations {
   @override
   String get reportDetailImageUnavailable => '報告圖尚未提供';
 
+  @override
+  String get reportDetailImageSave => '儲存圖片';
+
+  @override
+  String get reportDetailImageSaved => '已儲存到相簿';
+
+  @override
+  String get reportDetailImageSaveFailed => '儲存圖片失敗';
+
+  @override
+  String get reportDetailImageSavePermissionDenied => '要相簿權限先可以儲存圖片';
+
   @override
   String get reportDetailReplay => '重播';
 
@@ -2497,6 +2515,9 @@ class AppLocalizationsYue extends AppLocalizations {
   @override
   String get mapTownLabels => '鄉鎮名稱';
 
+  @override
+  String get mapSettingsPanel => '地圖設定面板';
+
   @override
   String get notifySetFailed => '設定失敗,請稍後再試。';
 
diff --git a/lib/l10n/gen/app_localizations_zh.dart b/lib/l10n/gen/app_localizations_zh.dart
index a8abe4261..b01021975 100644
--- a/lib/l10n/gen/app_localizations_zh.dart
+++ b/lib/l10n/gen/app_localizations_zh.dart
@@ -1056,6 +1056,12 @@ class AppLocalizationsZh extends AppLocalizations {
   @override
   String get mapLayers => '圖層';
 
+  @override
+  String get mapImmersive => '沉浸式地圖';
+
+  @override
+  String get mapImmersiveExit => '結束沉浸式';
+
   @override
   String get meshtasticHardware => '硬體';
 
@@ -1222,6 +1228,18 @@ class AppLocalizationsZh extends AppLocalizations {
   @override
   String get reportDetailImageUnavailable => '報告圖尚未提供';
 
+  @override
+  String get reportDetailImageSave => '儲存圖片';
+
+  @override
+  String get reportDetailImageSaved => '已儲存到相簿';
+
+  @override
+  String get reportDetailImageSaveFailed => '儲存圖片失敗';
+
+  @override
+  String get reportDetailImageSavePermissionDenied => '需要相簿權限才能儲存圖片';
+
   @override
   String get reportDetailReplay => '重播';
 
@@ -2497,6 +2515,9 @@ class AppLocalizationsZh extends AppLocalizations {
   @override
   String get mapTownLabels => '鄉鎮名稱';
 
+  @override
+  String get mapSettingsPanel => '地圖設定面板';
+
   @override
   String get notifySetFailed => '設定失敗，請稍後再試。';
 
@@ -4599,6 +4620,12 @@ class AppLocalizationsZhHans extends AppLocalizationsZh {
   @override
   String get mapLayers => '图层';
 
+  @override
+  String get mapImmersive => '沉浸式地图';
+
+  @override
+  String get mapImmersiveExit => '退出沉浸模式';
+
   @override
   String get meshtasticHardware => '硬件';
 
@@ -4765,6 +4792,18 @@ class AppLocalizationsZhHans extends AppLocalizationsZh {
   @override
   String get reportDetailImageUnavailable => '报告图尚未提供';
 
+  @override
+  String get reportDetailImageSave => '保存图片';
+
+  @override
+  String get reportDetailImageSaved => '已保存到相册';
+
+  @override
+  String get reportDetailImageSaveFailed => '保存图片失败';
+
+  @override
+  String get reportDetailImageSavePermissionDenied => '需要相册权限才能保存图片';
+
   @override
   String get reportDetailReplay => '重播';
 
@@ -6040,6 +6079,9 @@ class AppLocalizationsZhHans extends AppLocalizationsZh {
   @override
   String get mapTownLabels => '乡镇名称';
 
+  @override
+  String get mapSettingsPanel => '地图设置面板';
+
   @override
   String get notifySetFailed => '设置失败，请稍后再试。';
 
@@ -8141,6 +8183,12 @@ class AppLocalizationsZhHantHk extends AppLocalizationsZh {
   @override
   String get mapLayers => '圖層';
 
+  @override
+  String get mapImmersive => '沉浸式地圖';
+
+  @override
+  String get mapImmersiveExit => '結束沉浸式';
+
   @override
   String get meshtasticHardware => '硬體';
 
@@ -8307,6 +8355,18 @@ class AppLocalizationsZhHantHk extends AppLocalizationsZh {
   @override
   String get reportDetailImageUnavailable => '報告圖尚未提供';
 
+  @override
+  String get reportDetailImageSave => '儲存圖片';
+
+  @override
+  String get reportDetailImageSaved => '已儲存到相簿';
+
+  @override
+  String get reportDetailImageSaveFailed => '儲存圖片失敗';
+
+  @override
+  String get reportDetailImageSavePermissionDenied => '需要相簿權限才能儲存圖片';
+
   @override
   String get reportDetailReplay => '重播';
 
@@ -9582,6 +9642,9 @@ class AppLocalizationsZhHantHk extends AppLocalizationsZh {
   @override
   String get mapTownLabels => '鄉鎮名稱';
 
+  @override
+  String get mapSettingsPanel => '地圖設定面板';
+
   @override
   String get notifySetFailed => '設定失敗,請稍後再試。';
 
@@ -11684,6 +11747,12 @@ class AppLocalizationsZhTw extends AppLocalizationsZh {
   @override
   String get mapLayers => '圖層';
 
+  @override
+  String get mapImmersive => '沉浸式地圖';
+
+  @override
+  String get mapImmersiveExit => '結束沉浸式';
+
   @override
   String get meshtasticHardware => '硬體';
 
@@ -11850,6 +11919,18 @@ class AppLocalizationsZhTw extends AppLocalizationsZh {
   @override
   String get reportDetailImageUnavailable => '報告圖尚未提供';
 
+  @override
+  String get reportDetailImageSave => '儲存圖片';
+
+  @override
+  String get reportDetailImageSaved => '已儲存到相簿';
+
+  @override
+  String get reportDetailImageSaveFailed => '儲存圖片失敗';
+
+  @override
+  String get reportDetailImageSavePermissionDenied => '需要相簿權限才能儲存圖片';
+
   @override
   String get reportDetailReplay => '重播';
 
@@ -13125,6 +13206,9 @@ class AppLocalizationsZhTw extends AppLocalizationsZh {
   @override
   String get mapTownLabels => '鄉鎮名稱';
 
+  @override
+  String get mapSettingsPanel => '地圖設定面板';
+
   @override
   String get notifySetFailed => '設定失敗，請稍後再試。';
 
diff --git a/lib/shared/map/base_map.dart b/lib/shared/map/base_map.dart
index b4de3799f..5d51c8ca2 100644
--- a/lib/shared/map/base_map.dart
+++ b/lib/shared/map/base_map.dart
@@ -554,6 +554,18 @@ class _BaseMapState extends State<BaseMap> with WidgetsBindingObserver {
       compassEnabled: widget.interactive && widget.compassEnabled,
       compassViewPosition: CompassViewPosition.topRight,
       compassViewMargins: Point(AppSpacing.lg, compassTop),
+      // MapLibre draws its own attribution (i) ornament in the bottom-right
+      // corner. The plugin exposes no visibility flag, so push it past the
+      // trailing/bottom edges with negative margins — the platform view clips,
+      // so it is neither painted nor tappable. iOS also tints it clear as a
+      // second line of defence; Android treats a clear tint as "keep the
+      // default", so the margin is the fix there. The attribution text itself
+      // stays in More → data sources ("© OpenStreetMap contributors").
+      // Replace this with an `attributionButtonEnabled: false` option if the
+      // maplibre_gl fork ever grows one.
+      attributionButtonPosition: AttributionButtonPosition.bottomRight,
+      attributionButtonMargins: const Point(-4000, -4000),
+      attributionButtonColor: Colors.transparent,
       scrollGesturesEnabled: widget.interactive,
       zoomGesturesEnabled: widget.interactive,
       rotateGesturesEnabled: widget.interactive,
diff --git a/lib/shared/map/map_image_density.dart b/lib/shared/map/map_image_density.dart
new file mode 100644
index 000000000..96c2efb03
--- /dev/null
+++ b/lib/shared/map/map_image_density.dart
@@ -0,0 +1,78 @@
+/// How MapLibre turns an added image's pixels into points, and the one place
+/// that difference is cancelled out.
+///
+/// `addImage` has no pixel-ratio argument in this fork, so every icon's
+/// on-screen size is fixed by the density the platform records **with the
+/// image**, and the two platforms disagree:
+///
+/// - **iOS** decodes at `UIScreen.main.scale` (`MapLibreMapController.swift`,
+///   `style#addImage`), so a 64px badge is 64/3 ≈ 21pt on a 3x phone and 64pt
+///   on a 1x display.
+/// - **Android** decodes with `inDensity = 0`, which leaves the bitmap at
+///   Android's default density (160dpi) and makes MapLibre's
+///   `bitmap.getDensity() / 160` a pixel ratio of **1.0** on every device
+///   (`MapLibreMapController.java`, `style#addImage`). A 64px badge therefore
+///   lands at 64dp — three times the iPhone's.
+///
+/// So the same `icon-size` curve renders at three different physical sizes.
+/// [mapIconDensityFactor] is the multiplier that cancels the platform's own
+/// divisor, expressed against the size the design was drawn at: a 3x iPhone.
+/// Multiply every pixel-based icon-size curve by it and the curve's numbers
+/// mean dp/pt on both platforms, at every density.
+library;
+
+import 'dart:io';
+
+import 'package:flutter/widgets.dart';
+
+/// The image scale the icon-size curves were tuned against — a 3x iPhone.
+///
+/// Not a platform fact but a design decision: the badge sizes on a 3x iPhone
+/// are the ones that shipped and looked right, so they are what every other
+/// platform is brought to.
+const double _referenceImageScale = 3;
+
+/// The multiplier that turns a pixel-based `icon-size` curve into one expressed
+/// in dp/pt.
+///
+/// `renderedPoints = artworkPixels × iconSize / platformDivisor`, so
+/// `iconSize = curve × platformDivisor / referenceScale` renders
+/// `artworkPixels × curve / referenceScale` **points** everywhere — the 3x
+/// iPhone size — instead of on Android three times that.
+///
+/// The arguments exist to test the selection: `dart:io` `Platform` answers for
+/// the machine the test runs on, and `PlatformDispatcher` in a widget test is
+/// not a phone's. Production passes neither.
+double mapIconDensityFactor({
+  double? devicePixelRatio,
+  bool? isIOS,
+  bool? isAndroid,
+}) {
+  final ios = isIOS ?? Platform.isIOS;
+  final android = isAndroid ?? Platform.isAndroid;
+  if (!ios && !android) return 1;
+  if (!ios) return 1 / _referenceImageScale; // Android's divisor is a fixed 1.
+  final ratio = devicePixelRatio ?? _dispatcherPixelRatio();
+  return ratio / _referenceImageScale;
+}
+
+double _dispatcherPixelRatio() {
+  final views = WidgetsBinding.instance.platformDispatcher.views;
+  return views.isEmpty ? _referenceImageScale : views.first.devicePixelRatio;
+}
+
+/// The zoom curve for the 64px intensity artwork — the 強震監視器's station
+/// badges and the report map's town/epicentre markers, which were always drawn
+/// at the same scale.
+///
+/// The numbers are a fraction of the artwork's pixels: 0.75 of 64px at zoom 5,
+/// 1.7 at zoom 15. Multiply by [mapIconDensityFactor] to make them dp/pt.
+List<Object> intensityIconSizeCurve(double densityFactor) => [
+  'interpolate',
+  ['linear'],
+  ['zoom'],
+  5,
+  0.75 * densityFactor,
+  15,
+  1.7 * densityFactor,
+];
diff --git a/lib/shared/map/map_immersive.dart b/lib/shared/map/map_immersive.dart
new file mode 100644
index 000000000..9fbf859dc
--- /dev/null
+++ b/lib/shared/map/map_immersive.dart
@@ -0,0 +1,38 @@
+/// The map surface's immersive view mode — chrome hidden, map edge to edge.
+library;
+
+import 'package:dpip/app/theme/app_motion.dart';
+import 'package:flutter/animation.dart';
+import 'package:flutter/foundation.dart';
+
+/// How long the map chrome and the shell's navigation bar take to clear or
+/// return. One choreography for both surfaces: the bar and the chrome have to
+/// move together or the mode reads as two separate changes.
+const Duration mapImmersiveTransition = AppMotion.medium;
+
+/// The easing both surfaces use for that transition.
+const Curve mapImmersiveCurve = Curves.easeOutCubic;
+
+/// Whether a map surface is in immersive mode.
+///
+/// The map tab's instance is installed app-wide rather than held by the
+/// scaffold because two widgets on opposite sides of the tree have to agree:
+/// the scaffold hides the map chrome, and `MainShell` slides the bottom
+/// navigation away so the map really does fill the screen. A [ValueNotifier] so
+/// only those two listeners rebuild when it flips, not the platform-view map
+/// underneath them. A full-screen map that owns its own chrome (the earthquake
+/// replay) holds a page-scoped instance instead — it has no shell nav bar to
+/// move, and must not leave the map tab's mode behind when it pops.
+///
+/// Deliberately not persisted. Immersive is a way of looking at the map right
+/// now, not a preference: a launch that restored it would greet the user with
+/// a chrome-less map and no visible way out of it.
+class MapImmersiveController extends ValueNotifier<bool> {
+  MapImmersiveController() : super(false);
+
+  /// Hides the map chrome and the shell's navigation bar.
+  void enter() => value = true;
+
+  /// Brings the controls back.
+  void exit() => value = false;
+}
diff --git a/lib/shared/map/map_immersive_chrome.dart b/lib/shared/map/map_immersive_chrome.dart
new file mode 100644
index 000000000..de1b75b2d
--- /dev/null
+++ b/lib/shared/map/map_immersive_chrome.dart
@@ -0,0 +1,96 @@
+/// Shared immersive-mode chrome for the app's full-screen map surfaces.
+library;
+
+import 'package:dpip/l10n/gen/app_localizations.dart';
+import 'package:dpip/shared/map/map_immersive.dart';
+import 'package:dpip/shared/widgets/map_chip_button.dart';
+import 'package:flutter/material.dart';
+
+/// Fades and nudges a block of map chrome as immersive mode toggles.
+///
+/// Blocks stay mounted: the map's timeline carries a [GlobalKey] for
+/// measurement, and swapping it out and back mid-transition could duplicate
+/// that key on a fast double-tap. Hidden therefore means opacity 0 plus no hit
+/// testing, semantics or focus — not absence.
+class MapImmersiveChrome extends StatelessWidget {
+  const MapImmersiveChrome({
+    super.key,
+    required this.hidden,
+    required this.child,
+    this.slide = const Offset(0, -0.08),
+  });
+
+  /// Whether the chrome is on its way out (or already gone).
+  final bool hidden;
+
+  final Widget child;
+
+  /// Where the block drifts as it fades, as a fraction of its own size. The
+  /// timeline passes a downward offset; top-edge chrome takes the default lift.
+  final Offset slide;
+
+  @override
+  Widget build(BuildContext context) {
+    return IgnorePointer(
+      ignoring: hidden,
+      child: ExcludeSemantics(
+        excluding: hidden,
+        child: ExcludeFocus(
+          excluding: hidden,
+          child: AnimatedSlide(
+            duration: mapImmersiveTransition,
+            curve: mapImmersiveCurve,
+            offset: hidden ? slide : Offset.zero,
+            child: AnimatedOpacity(
+              duration: mapImmersiveTransition,
+              curve: mapImmersiveCurve,
+              opacity: hidden ? 0 : 1,
+              child: child,
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+/// The one control immersive mode leaves on screen: the way back out.
+///
+/// Callers paint it above the layer's own sheet — a detail sheet dragged to
+/// full height must not bury the only control left, because iOS has no system
+/// back gesture to fall back on.
+class MapImmersiveExitChip extends StatelessWidget {
+  const MapImmersiveExitChip({
+    super.key,
+    required this.immersive,
+    required this.onExit,
+  });
+
+  final bool immersive;
+  final VoidCallback onExit;
+
+  @override
+  Widget build(BuildContext context) {
+    return AnimatedSwitcher(
+      duration: mapImmersiveTransition,
+      switchInCurve: mapImmersiveCurve,
+      switchOutCurve: Curves.easeInCubic,
+      transitionBuilder: (child, animation) => FadeTransition(
+        opacity: animation,
+        child: ScaleTransition(
+          scale: Tween<double>(begin: 0.88, end: 1).animate(animation),
+          child: child,
+        ),
+      ),
+      child: immersive
+          ? MapChipButton(
+              key: const ValueKey('map-immersive-exit'),
+              icon: Icons.fullscreen_exit,
+              tooltip: AppLocalizations.of(context).mapImmersiveExit,
+              active: false,
+              onTap: onExit,
+            )
+          : const SizedBox.shrink(key: ValueKey('map-immersive-exit-hidden')),
+    );
+  }
+}
diff --git a/lib/shared/map/map_scaffold.dart b/lib/shared/map/map_scaffold.dart
index 68f6fa3db..20d5c9989 100644
--- a/lib/shared/map/map_scaffold.dart
+++ b/lib/shared/map/map_scaffold.dart
@@ -22,6 +22,8 @@ import 'package:dpip/shared/map/map_layer_switcher.dart';
 import 'package:dpip/shared/map/map_compass.dart';
 import 'package:dpip/shared/map/basemap_overlay_sync.dart';
 import 'package:dpip/shared/map/map_gsi_overlay.dart';
+import 'package:dpip/shared/map/map_immersive.dart';
+import 'package:dpip/shared/map/map_immersive_chrome.dart';
 import 'package:dpip/shared/map/map_style.dart';
 import 'package:dpip/shared/map/map_timeline.dart';
 import 'package:dpip/shared/map/map_town_labels.dart';
@@ -31,6 +33,7 @@ import 'package:dpip/shared/navigation/refresh_on_appear.dart'
     show VisibleTab, VisibleTabScope;
 import 'package:dpip/shared/widgets/collapsible_map_legend.dart';
 import 'package:dpip/shared/widgets/frosted_surface.dart';
+import 'package:dpip/shared/widgets/map_chip_button.dart';
 import 'package:flutter/material.dart';
 import 'package:maplibre_gl/maplibre_gl.dart';
 import 'package:provider/provider.dart';
@@ -123,6 +126,11 @@ class _MapScaffoldState extends State<MapScaffold> with WidgetsBindingObserver {
   /// itself was just tapped from.
   MapLayerVisibilityController? _visibility;
 
+  /// The map tab's immersive toggle — chrome hidden, shell nav dismissed. Read
+  /// through a listener rather than `context.watch` so entering the mode can
+  /// also drop the measured timeline height (see [_onImmersiveChanged]).
+  MapImmersiveController? _immersive;
+
   late MapLayer _active = _resolveInitial(widget);
 
   static MapLayer _resolveInitial(MapScaffold widget) {
@@ -259,6 +267,11 @@ class _MapScaffoldState extends State<MapScaffold> with WidgetsBindingObserver {
       _visibility?.removeListener(_onVisibilityChanged);
       _visibility = visibility..addListener(_onVisibilityChanged);
     }
+    final immersive = context.read<MapImmersiveController>();
+    if (immersive != _immersive) {
+      _immersive?.removeListener(_onImmersiveChanged);
+      _immersive = immersive..addListener(_onImmersiveChanged);
+    }
     final visibleTab = VisibleTabScope.of(context);
     if (identical(visibleTab, _visibleTab)) return;
     _visibleTab?.removeListener(_onTabChanged);
@@ -352,6 +365,7 @@ class _MapScaffoldState extends State<MapScaffold> with WidgetsBindingObserver {
     _handoff?.removeListener(_onHandoff);
     _stationHandoff?.removeListener(_onStationHandoff);
     _visibility?.removeListener(_onVisibilityChanged);
+    _immersive?.removeListener(_onImmersiveChanged);
     super.dispose();
   }
 
@@ -375,6 +389,16 @@ class _MapScaffoldState extends State<MapScaffold> with WidgetsBindingObserver {
           'style=$_styleLoaded controller=${mapTraceObject(_controller)}',
     );
     _wasVisible = visible;
+    // The controller is shared with the shell, which hides its bar for any
+    // immersive-capable branch. Leaving this tab must clear it, or a stale
+    // true would follow the user to another branch (or the replay's route)
+    // and hide a bar with no immersive surface behind it.
+    final tabIndex = widget.tabIndex;
+    if ((_immersive?.value ?? false) &&
+        tabIndex != null &&
+        _visibleTab?.value != tabIndex) {
+      _immersive?.exit();
+    }
     // Both edges, before the timeline reload: a realtime layer skips its
     // platform uploads while hidden and flushes once on return.
     if (changed) _active.onSurfaceVisibility(visible);
@@ -578,8 +602,13 @@ class _MapScaffoldState extends State<MapScaffold> with WidgetsBindingObserver {
   /// How much of the map's bottom the active layer's resting chrome hides: the
   /// layer's own declared share (a collapsed sheet, a status strip) plus the
   /// timeline, whose real height the scaffold measures because it owns it.
+  ///
+  /// The timeline keeps its place in the tree while immersive — it fades out
+  /// rather than unmounting — so its measured height is still real; it just is
+  /// not in the way any more.
   double _bottomInset(Size size) =>
-      size.height * _active.bottomChromeFraction + _timelineHeight;
+      size.height * _active.bottomChromeFraction +
+      ((_immersive?.value ?? false) ? 0 : _timelineHeight);
 
   /// Measures the timeline panel after layout.
   ///
@@ -1262,23 +1291,82 @@ class _MapScaffoldState extends State<MapScaffold> with WidgetsBindingObserver {
     if (candidate.id != _active.id) _onLayerSelected(candidate);
   }
 
+  /// Drops a sheet layer's bottom chrome toward the space the shell's nav bar
+  /// leaves behind in immersive mode.
+  ///
+  /// `MainShell` extends its body behind the nav bar, so Scaffold adds the
+  /// bar's height to this subtree's MediaQuery padding. Sliding the bar away
+  /// does not shrink that padding, which left the 強震監視器 status strip — and
+  /// every other sheet layer's peek — floating a bar's height above the
+  /// bottom. Animate the inset away on the same curve as the bar, but stop one
+  /// spacing token above the system inset: flush against it read as too low
+  /// next to the home indicator, while the bar's full height read as a gap.
+  Widget _immersiveSheetInset({
+    required bool immersive,
+    required Widget child,
+  }) {
+    return TweenAnimationBuilder<double>(
+      tween: Tween<double>(end: immersive ? 1 : 0),
+      duration: mapImmersiveTransition,
+      curve: mapImmersiveCurve,
+      builder: (context, progress, child) {
+        final media = MediaQuery.of(context);
+        final extra = media.padding.bottom - media.viewPadding.bottom;
+        if (extra <= 0) return child!;
+        final settled = media.viewPadding.bottom + AppSpacing.lg;
+        return MediaQuery(
+          data: media.copyWith(
+            padding: media.padding.copyWith(
+              bottom:
+                  media.padding.bottom +
+                  (settled - media.padding.bottom) * progress,
+            ),
+          ),
+          child: child!,
+        );
+      },
+      child: child,
+    );
+  }
+
+  /// Enters/leaves immersive mode.
+  ///
+  /// The chrome stays mounted and cross-fades (see [MapImmersiveChrome]), so
+  /// the only state this has to rebuild is the target of those animations.
+  void _onImmersiveChanged() {
+    if (!mounted) return;
+    setState(() {});
+  }
+
   @override
   Widget build(BuildContext context) {
-    return Scaffold(
-      body: GsiOverlayScope(
-        controller: _gsi,
-        child: LayoutBuilder(
-          builder: (context, constraints) {
-            final measured = constraints.biggest;
-            if (measured.isFinite) _mapViewSize = measured;
-            return _body(context);
-          },
+    final immersive = _immersive?.value ?? false;
+    return PopScope(
+      // While immersive the first back gesture belongs to the mode, not to the
+      // app: a user who hid every control must not have to find the exit chip
+      // to avoid leaving DPIP. A modal sheet over the map still gets the back
+      // press first, because it is its own route.
+      canPop: !immersive,
+      onPopInvokedWithResult: (didPop, _) {
+        if (!didPop) _immersive?.exit();
+      },
+      child: Scaffold(
+        body: GsiOverlayScope(
+          controller: _gsi,
+          child: LayoutBuilder(
+            builder: (context, constraints) {
+              final measured = constraints.biggest;
+              if (measured.isFinite) _mapViewSize = measured;
+              return _body(context);
+            },
+          ),
         ),
       ),
     );
   }
 
   Widget _body(BuildContext context) {
+    final immersive = _immersive?.value ?? false;
     // The timeline's height depends on its content, so measure it after every
     // build; a change re-frames (see [_measureTimeline]).
     if (_active.usesTimeline) _measureTimeline();
@@ -1354,125 +1442,176 @@ class _MapScaffoldState extends State<MapScaffold> with WidgetsBindingObserver {
         Positioned(
           top: 0,
           left: 0,
-          child: SafeArea(
-            child: Padding(
-              padding: const EdgeInsets.all(AppSpacing.lg),
-              child: Column(
-                crossAxisAlignment: CrossAxisAlignment.start,
-                mainAxisSize: MainAxisSize.min,
-                children: [
-                  CollapsibleMapLegend(
-                    key: ValueKey(_active.id),
-                    legend: _active.buildLegend(context),
-                  ),
-                  ?_active.buildLegendAccessory(context),
-                ],
+          child: MapImmersiveChrome(
+            hidden: immersive,
+            child: SafeArea(
+              child: Padding(
+                padding: const EdgeInsets.all(AppSpacing.lg),
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    CollapsibleMapLegend(
+                      key: ValueKey(_active.id),
+                      legend: _active.buildLegend(context),
+                    ),
+                    ?_active.buildLegendAccessory(context),
+                  ],
+                ),
               ),
             ),
           ),
         ),
-        // Layer switcher (+ optional layer chrome) — top-right.
+        // Layer switcher (+ optional layer chrome) — top-right. Immersive
+        // mode's own exit chip paints above the sheet at the end of this stack
+        // — see there for why.
         Positioned(
           top: 0,
           right: 0,
-          child: SafeArea(
-            child: Padding(
-              padding: const EdgeInsets.all(AppSpacing.lg),
-              child: Builder(
-                builder: (context) {
-                  // Layers with a settings menu (radar / QPESUMS / DPM / typhoon
-                  // / rain) receive the shared township-label toggle to carry;
-                  // the rest return [SizedBox.shrink], so show the standalone
-                  // township-label menu instead — every layer can set it.
-                  final chrome = _active.buildTopTrailingChrome(
-                    context,
-                    showTownLabels: _showTownLabels,
-                    onShowTownLabelsChanged: _setShowTownLabels,
-                    showTerrain: _showTerrain,
-                    onShowTerrainChanged: _setShowTerrain,
-                    onReloadActive: _reloadActive,
-                  );
-                  final hasChrome = chrome is! SizedBox;
-                  return Row(
-                    mainAxisSize: MainAxisSize.min,
-                    children: [
-                      if (hasChrome) ...[
-                        chrome,
-                        const SizedBox(width: AppSpacing.sm),
-                      ] else ...[
-                        MapBasemapMenu(
-                          showTownLabels: _showTownLabels,
-                          onShowTownLabelsChanged: _setShowTownLabels,
-                          showTerrain: _showTerrain,
-                          onShowTerrainChanged: _setShowTerrain,
+          child: MapImmersiveChrome(
+            hidden: immersive,
+            child: SafeArea(
+              child: Padding(
+                padding: const EdgeInsets.all(AppSpacing.lg),
+                child: Builder(
+                  builder: (context) {
+                    // Layers with a settings menu (radar / QPESUMS / DPM / typhoon
+                    // / rain) receive the shared township-label toggle to carry;
+                    // the rest return [SizedBox.shrink], so show the standalone
+                    // township-label menu instead — every layer can set it.
+                    final chrome = _active.buildTopTrailingChrome(
+                      context,
+                      showTownLabels: _showTownLabels,
+                      onShowTownLabelsChanged: _setShowTownLabels,
+                      showTerrain: _showTerrain,
+                      onShowTerrainChanged: _setShowTerrain,
+                      onReloadActive: _reloadActive,
+                    );
+                    final hasChrome = chrome is! SizedBox;
+                    return Row(
+                      mainAxisSize: MainAxisSize.min,
+                      children: [
+                        // Immersive toggle, left of the layer's own options and
+                        // the layer selector: it presents the whole map rather
+                        // than filtering what is drawn on it, so it leads the
+                        // row instead of living inside the layer picker.
+                        MapChipButton(
+                          icon: Icons.fullscreen,
+                          tooltip: AppLocalizations.of(context).mapImmersive,
+                          active: false,
+                          onTap: () => _immersive?.enter(),
                         ),
                         const SizedBox(width: AppSpacing.sm),
+                        if (hasChrome) ...[
+                          chrome,
+                          const SizedBox(width: AppSpacing.sm),
+                        ] else ...[
+                          MapBasemapMenu(
+                            showTownLabels: _showTownLabels,
+                            onShowTownLabelsChanged: _setShowTownLabels,
+                            showTerrain: _showTerrain,
+                            onShowTerrainChanged: _setShowTerrain,
+                          ),
+                          const SizedBox(width: AppSpacing.sm),
+                        ],
+                        MapLayerSwitcher(
+                          layers: widget.layers,
+                          active: _active,
+                          onSelected: _onLayerSelected,
+                        ),
                       ],
-                      MapLayerSwitcher(
-                        layers: widget.layers,
-                        active: _active,
-                        onSelected: _onLayerSelected,
-                      ),
-                    ],
-                  );
-                },
+                    );
+                  },
+                ),
               ),
             ),
           ),
         ),
         // Sheet / timeline last so they paint above the chrome when expanded.
         if (!_active.usesTimeline)
-          Positioned.fill(child: _active.buildSheet(context)),
+          Positioned.fill(
+            child: _immersiveSheetInset(
+              immersive: immersive,
+              child: _active.buildSheet(context),
+            ),
+          ),
         if (_active.usesTimeline)
           Positioned(
             left: 0,
             right: 0,
             bottom: 0,
-            child: SafeArea(
-              key: _timelineKey,
-              top: false,
-              child: Stack(
-                clipBehavior: Clip.none,
-                children: [
-                  _frames.isNotEmpty
-                      ? _timelinePanel(context)
-                      : _error != null
-                      ? _errorPanel(context)
-                      : const SizedBox.shrink(),
-                  if (_frames.isNotEmpty)
-                    Positioned(
-                      top: 0,
-                      left: AppSpacing.lg,
-                      right: AppSpacing.lg,
-                      child: IgnorePointer(
-                        child: Transform.translate(
-                          offset: const Offset(0, -AppSpacing.sm),
-                          child: FractionalTranslation(
-                            translation: const Offset(0, -1),
-                            child: MapTimelineScrubPauseNotice(
-                              paused: _scrubBackpressure,
+            child: MapImmersiveChrome(
+              hidden: immersive,
+              // Slides back down as it clears, then rises on the way back.
+              slide: const Offset(0, 0.25),
+              child: SafeArea(
+                key: _timelineKey,
+                top: false,
+                child: Stack(
+                  clipBehavior: Clip.none,
+                  children: [
+                    _frames.isNotEmpty
+                        ? _timelinePanel(context)
+                        : _error != null
+                        ? _errorPanel(context)
+                        : const SizedBox.shrink(),
+                    if (_frames.isNotEmpty)
+                      Positioned(
+                        top: 0,
+                        left: AppSpacing.lg,
+                        right: AppSpacing.lg,
+                        child: IgnorePointer(
+                          child: Transform.translate(
+                            offset: const Offset(0, -AppSpacing.sm),
+                            child: FractionalTranslation(
+                              translation: const Offset(0, -1),
+                              child: MapTimelineScrubPauseNotice(
+                                paused: _scrubBackpressure,
+                              ),
                             ),
                           ),
                         ),
                       ),
-                    ),
-                ],
+                  ],
+                ),
               ),
             ),
           ),
         // Compass on top of *everything* — a screen-space callout (typhoon
         // forecast tips) or an expanded sheet must never hide north. Parked
         // just under the layer switcher chip, with a touch of breathing room.
+        // It fades out with the rest of the chrome while immersive.
+        Positioned(
+          top: 0,
+          right: 0,
+          child: MapImmersiveChrome(
+            hidden: immersive,
+            child: SafeArea(
+              child: Padding(
+                padding: EdgeInsets.only(
+                  top: layerChipBand + AppSpacing.sm,
+                  right: AppSpacing.lg,
+                ),
+                child: MapCompass(bearing: _bearing, onPressed: _resetNorth),
+              ),
+            ),
+          ),
+        ),
+        // The way out of immersive mode, above *everything* — including the
+        // layer's own sheet. Those sheets can be dragged to full height (DPM,
+        // typhoon, tsunami), and one covering the top-right corner would bury
+        // the only control left: Android's back gesture also leaves the mode,
+        // but iOS has no equivalent, so a buried chip is a dead end.
         Positioned(
           top: 0,
           right: 0,
           child: SafeArea(
             child: Padding(
-              padding: EdgeInsets.only(
-                top: layerChipBand + AppSpacing.sm,
-                right: AppSpacing.lg,
+              padding: const EdgeInsets.all(AppSpacing.lg),
+              child: MapImmersiveExitChip(
+                immersive: immersive,
+                onExit: () => _immersive?.exit(),
               ),
-              child: MapCompass(bearing: _bearing, onPressed: _resetNorth),
             ),
           ),
         ),
diff --git a/lib/shared/map/map_town_labels.dart b/lib/shared/map/map_town_labels.dart
index 6f2ec8db6..810e6afe9 100644
--- a/lib/shared/map/map_town_labels.dart
+++ b/lib/shared/map/map_town_labels.dart
@@ -118,7 +118,7 @@ class MapBasemapMenu extends StatelessWidget {
         style: MapChipButton.menuStyle(context),
         builder: (context, controller, _) => MapChipButton(
           icon: Icons.tune,
-          tooltip: l10n.mapTownLabels,
+          tooltip: l10n.mapSettingsPanel,
           active:
               !showTownLabels.value ||
               !showTerrain.value ||
diff --git a/lib/shared/map/monitor_map_stack.dart b/lib/shared/map/monitor_map_stack.dart
index 515db5844..97f653dc2 100644
--- a/lib/shared/map/monitor_map_stack.dart
+++ b/lib/shared/map/monitor_map_stack.dart
@@ -19,6 +19,7 @@ library;
 import 'package:dpip/core/a11y/color_vision.dart';
 import 'package:dpip/core/logging/log.dart';
 import 'package:dpip/shared/color_hex.dart';
+import 'package:dpip/shared/map/map_image_density.dart';
 import 'package:dpip/shared/map/map_station_labels.dart';
 import 'package:dpip/shared/map/map_style.dart' show landLayerId;
 import 'package:dpip/shared/seismic/intensity_circle_renderer.dart';
@@ -122,22 +123,6 @@ const List<Object> monitorDotRadius = [
   8.0,
 ];
 
-/// The discrete-reading badge's on-map scale of its 64px artwork. The legacy
-/// monitor's own badge layer used 0.2 at z5 → 0.8 at z10, but that assumed
-/// native-resolution PNG assets — applied to a baked canvas here it renders at
-/// only device-pixel size, ~13px on a 3x display and effectively invisible.
-/// `ReportDetailPage` already solved this for the same 64px canvas class (see
-/// [IntensityIconRenderer]); this is its scale.
-const List<Object> monitorBadgeIconSize = [
-  'interpolate',
-  ['linear'],
-  ['zoom'],
-  5,
-  0.75,
-  15,
-  1.7,
-];
-
 /// Higher intensity draws on top (dot, badge and label all key off this) —
 /// reads `sort`, the reading the badge is drawn from. Stations without a
 /// `sort` sink.
@@ -266,6 +251,7 @@ Future<void> addMonitorLayers(
   MonitorLayerIds ids, {
   Map<String, dynamic> stationData = monitorEmptyCollection,
   double dotOpacity = 1,
+  double? iconDensityFactor,
   required String logTag,
 }) async {
   await controller.addSource(
@@ -294,9 +280,11 @@ Future<void> addMonitorLayers(
   await controller.addSymbolLayer(
     ids.stationSource,
     ids.stationBadge,
-    const SymbolLayerProperties(
-      iconImage: <Object>['get', 'icon'],
-      iconSize: monitorBadgeIconSize,
+    SymbolLayerProperties(
+      iconImage: const <Object>['get', 'icon'],
+      iconSize: intensityIconSizeCurve(
+        iconDensityFactor ?? mapIconDensityFactor(),
+      ),
       iconAllowOverlap: true,
       iconIgnorePlacement: true,
       // Same "stronger wins" rule as the dot layer's circleSortKey — two
@@ -381,7 +369,9 @@ Future<void> addMonitorLayers(
       ids.eewEpicenter,
       SymbolLayerProperties(
         iconImage: ids.eewCrossIcon,
-        iconSize: 1.0,
+        // The 96px cross is artwork too: without the factor an Android device
+        // draws it at 96dp against the iPhone's 32pt.
+        iconSize: iconDensityFactor ?? mapIconDensityFactor(),
         iconAllowOverlap: true,
         iconIgnorePlacement: true,
       ),
diff --git a/test/app/app_test.dart b/test/app/app_test.dart
index 648ff7e7e..d4b1fceb9 100644
--- a/test/app/app_test.dart
+++ b/test/app/app_test.dart
@@ -54,6 +54,7 @@ import 'package:dpip/core/settings/settings_store.dart';
 import 'package:dpip/core/settings/theme_controller.dart';
 import 'package:dpip/core/storage/app_database.dart';
 import 'package:dpip/features/onboarding/presentation/pages/onboarding_page.dart';
+import 'package:dpip/features/map/map_providers.dart';
 import 'package:dpip/shared/map/map_camera_handoff.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
@@ -109,6 +110,7 @@ void main() {
         deps: deps,
         providers: [
           ...coreProviders(deps),
+          ...mapProviders(),
           ChangeNotifierProvider<MapCameraHandoff>.value(value: handoff),
         ],
       ),
diff --git a/test/app/router/app_router_test.dart b/test/app/router/app_router_test.dart
index 014f7ef2e..7f62c93c6 100644
--- a/test/app/router/app_router_test.dart
+++ b/test/app/router/app_router_test.dart
@@ -65,6 +65,7 @@ import 'package:dpip/features/events/domain/event_repository.dart';
 import 'package:dpip/features/events/events_providers.dart';
 import 'package:dpip/features/home/home_providers.dart';
 import 'package:dpip/features/home/presentation/pages/home_page.dart';
+import 'package:dpip/features/map/map_providers.dart';
 import 'package:dpip/features/home/presentation/home_weather_controller.dart';
 import 'package:dpip/features/weather/domain/meteor_weather_repository.dart';
 import 'package:dpip/features/weather/domain/rain_hour_trend_repository.dart';
@@ -224,6 +225,7 @@ void main() {
           ...weatherProviders(deps),
           Provider<RadarRepository>.value(value: _Radar()),
           ...homeProviders(),
+          ...mapProviders(),
           _eew(),
           Provider<Future<SeismicTravelTimeTable>>.value(
             value: Future<SeismicTravelTimeTable>.value(
@@ -400,6 +402,7 @@ Widget _widgetRouterApp(SharedDeps deps, _WidgetWeather weather) =>
         ...weatherProviders(deps),
         Provider<RadarRepository>.value(value: _Radar()),
         ...homeProviders(),
+        ...mapProviders(),
         ChangeNotifierProvider<HomeWeatherController>(
           create: (_) => HomeWeatherController(
             weather,
diff --git a/test/app/shell/main_shell_test.dart b/test/app/shell/main_shell_test.dart
index ea3394e51..60ae423f8 100644
--- a/test/app/shell/main_shell_test.dart
+++ b/test/app/shell/main_shell_test.dart
@@ -25,6 +25,7 @@ import 'package:dpip/features/home/presentation/home_sheet_extent.dart';
 import 'package:dpip/l10n/gen/app_localizations.dart';
 import 'package:dpip/shared/map/default_map_layer_ui.dart';
 import 'package:dpip/shared/map/map_camera_handoff.dart';
+import 'package:dpip/shared/map/map_immersive.dart';
 import 'package:dpip/shared/navigation/app_routes.dart';
 import 'package:dpip/shared/navigation/refresh_on_appear.dart';
 import 'package:flutter/material.dart';
@@ -109,6 +110,9 @@ void main() {
           ),
           ChangeNotifierProvider<EndpointHealthMonitor>.value(value: endpoints),
           ChangeNotifierProvider<MeshUnread>.value(value: unread),
+          ChangeNotifierProvider<MapImmersiveController>(
+            create: (_) => MapImmersiveController(),
+          ),
         ],
         child: MaterialApp.router(
           locale: const Locale('en'),
@@ -144,6 +148,35 @@ void main() {
     expect(find.text('map-body'), findsOneWidget);
     expect(handoff.takePending()?.layerId, layers.layer.id);
 
+    // An immersive map owns the whole screen, so the shell's bar slides away
+    // with it and comes back on exit — the map cannot reach the bar itself.
+    final immersive = Provider.of<MapImmersiveController>(
+      tester.element(find.byType(MainShell)),
+      listen: false,
+    );
+    final label = find.text(layers.layer.label(l10n));
+    final restingY = tester.getTopLeft(label).dy;
+
+    immersive.enter();
+    await tester.pump();
+    // The first frame starts the transition without moving the bar yet; a
+    // snap would already be at the bottom here.
+    expect(tester.getTopLeft(label).dy, closeTo(restingY, 0.01));
+
+    await tester.pump(const Duration(milliseconds: 110));
+    final midway = tester.getTopLeft(label).dy;
+    expect(midway, greaterThan(restingY));
+
+    await tester.pump(const Duration(milliseconds: 200));
+    final hiddenY = tester.getTopLeft(label).dy;
+    expect(hiddenY, greaterThan(midway));
+    expect(hiddenY, greaterThan(600));
+
+    immersive.exit();
+    await tester.pump();
+    await tester.pump(const Duration(milliseconds: 300));
+    expect(tester.getTopLeft(label).dy, lessThan(600));
+
     unread.recordIncoming(1, 1);
     endpoints.failure(
       ApiTier.lbApi,
@@ -166,6 +199,17 @@ void main() {
     await tester.pump();
     expect(find.text('replay-body'), findsOneWidget);
 
+    // The replay is nested under the data branch; its immersive mode must
+    // retract the shell's bar even though the map branch is not selected.
+    immersive.enter();
+    await tester.pump();
+    await tester.pump(const Duration(milliseconds: 300));
+    expect(tester.getTopLeft(label).dy, greaterThan(600));
+    immersive.exit();
+    await tester.pump();
+    await tester.pump(const Duration(milliseconds: 300));
+    expect(tester.getTopLeft(label).dy, lessThan(600));
+
     await tester.tap(find.text(l10n.navHome));
     await tester.pump();
     await tester.pump();
diff --git a/test/core/platform/image_saver_test.dart b/test/core/platform/image_saver_test.dart
new file mode 100644
index 000000000..32897f818
--- /dev/null
+++ b/test/core/platform/image_saver_test.dart
@@ -0,0 +1,241 @@
+/// Saving an image asks for the photo-library grant **before** writing, then
+/// hands the bytes to the platform and reports back a typed result.
+///
+/// The platform half (MediaStore, `PHPhotoLibrary`) needs a real device to
+/// observe; what this pins is the boundary the UI depends on: the permission
+/// gate, what crosses the channel, and how each error code is classified.
+library;
+
+import 'package:dpip/core/error/failure.dart';
+import 'package:dpip/core/error/result.dart';
+import 'package:dpip/core/platform/image_saver.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:permission_handler/permission_handler.dart' as ph;
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  const channel = MethodChannel('com.exptech.dpip/image_saver');
+  final messenger =
+      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger;
+
+  tearDown(() => messenger.setMockMethodCallHandler(channel, null));
+
+  final bytes = Uint8List.fromList([1, 2, 3, 4]);
+
+  ImageSaveFailure? failureOf(Result<void> result) {
+    final failure = result.failureOrNull;
+    expect(failure, isA<ImageSaveFailure>());
+    return failure as ImageSaveFailure;
+  }
+
+  test('a platform with no photo library reports unavailable', () async {
+    final result = await const UnsupportedImageSaver().saveToGallery(
+      bytes: bytes,
+      fileName: 'dpip-earthquake-1.png',
+    );
+
+    expect(failureOf(result)!.reason, ImageSaveFailureReason.unavailable);
+    expect(
+      failureOf(await const UnsupportedImageSaver().ensurePermission())!.reason,
+      ImageSaveFailureReason.unavailable,
+    );
+  });
+
+  group('iOS', () {
+    test(
+      'sends the bytes, the name and the type once the library agrees',
+      () async {
+        Map<String, Object?>? arguments;
+        messenger.setMockMethodCallHandler(channel, (call) async {
+          if (call.method == 'status') return 'granted';
+          expect(call.method, 'save');
+          // The binding hands the payload over as a plain Map; casting it to a
+          // typed map here would throw inside the handler and fail the call.
+          arguments = (call.arguments as Map).cast<String, Object?>();
+          return null;
+        });
+
+        final result = await IosImageSaver(isSupportedPlatform: true)
+            .saveToGallery(bytes: bytes, fileName: 'dpip-earthquake-1.png');
+
+        expect(result.isOk, isTrue);
+        expect(arguments!['bytes'], equals(bytes));
+        expect(arguments!['fileName'], 'dpip-earthquake-1.png');
+        expect(arguments!['mimeType'], 'image/png');
+      },
+    );
+
+    test('a refused library fails before anything is written', () async {
+      var saved = false;
+      messenger.setMockMethodCallHandler(channel, (call) async {
+        if (call.method == 'status') return 'denied';
+        if (call.method == 'save') saved = true;
+        return null;
+      });
+
+      final result = await IosImageSaver(isSupportedPlatform: true)
+          .saveToGallery(bytes: bytes, fileName: 'dpip-earthquake-2.png');
+
+      expect(
+        failureOf(result)!.reason,
+        ImageSaveFailureReason.permissionDenied,
+      );
+      expect(saved, isFalse, reason: 'a refused save must not write');
+    });
+
+    test('asks once when the library has never been asked', () async {
+      final methods = <String>[];
+      messenger.setMockMethodCallHandler(channel, (call) async {
+        methods.add(call.method);
+        if (call.method == 'status') return 'notDetermined';
+        if (call.method == 'request') return 'granted';
+        return null;
+      });
+
+      final result = await IosImageSaver(isSupportedPlatform: true)
+          .saveToGallery(bytes: bytes, fileName: 'dpip-earthquake-3.png');
+
+      expect(result.isOk, isTrue);
+      expect(methods, ['status', 'request', 'save']);
+    });
+  });
+
+  group('Android', () {
+    test('API 29+ needs no storage grant at all', () async {
+      var asked = 0;
+      messenger.setMockMethodCallHandler(channel, (call) async {
+        if (call.method == 'status') return 'granted';
+        return null;
+      });
+
+      final result = await AndroidImageSaver(
+        isSupportedPlatform: true,
+        storageStatus: () async {
+          asked++;
+          return ph.PermissionStatus.denied;
+        },
+        requestStorage: () async {
+          asked++;
+          return ph.PermissionStatus.denied;
+        },
+      ).saveToGallery(bytes: bytes, fileName: 'dpip-earthquake-4.png');
+
+      expect(result.isOk, isTrue);
+      expect(asked, 0, reason: 'MediaStore needs no permission');
+    });
+
+    test('API 26–28 asks for the legacy grant when it is missing', () async {
+      final methods = <String>[];
+      messenger.setMockMethodCallHandler(channel, (call) async {
+        if (call.method == 'status') return 'denied';
+        methods.add(call.method);
+        return null;
+      });
+
+      var requested = 0;
+      final result = await AndroidImageSaver(
+        isSupportedPlatform: true,
+        storageStatus: () async => ph.PermissionStatus.denied,
+        requestStorage: () async {
+          requested++;
+          return ph.PermissionStatus.granted;
+        },
+      ).saveToGallery(bytes: bytes, fileName: 'dpip-earthquake-5.png');
+
+      expect(requested, 1, reason: 'asked once before the save');
+      expect(methods, ['save']);
+      expect(result.isOk, isTrue);
+    });
+
+    test('a permanently refused grant fails without prompting', () async {
+      var requested = 0;
+      var saved = false;
+      messenger.setMockMethodCallHandler(channel, (call) async {
+        if (call.method == 'status') return 'denied';
+        if (call.method == 'save') saved = true;
+        return null;
+      });
+
+      final result = await AndroidImageSaver(
+        isSupportedPlatform: true,
+        storageStatus: () async => ph.PermissionStatus.permanentlyDenied,
+        requestStorage: () async {
+          requested++;
+          return ph.PermissionStatus.permanentlyDenied;
+        },
+      ).saveToGallery(bytes: bytes, fileName: 'dpip-earthquake-6.png');
+
+      expect(
+        requested,
+        0,
+        reason: 'a permanently denied grant cannot be asked',
+      );
+      expect(saved, isFalse);
+      expect(
+        failureOf(result)!.reason,
+        ImageSaveFailureReason.permissionDenied,
+      );
+    });
+
+    test('a grant the user refuses at the prompt is not retried', () async {
+      var saved = false;
+      messenger.setMockMethodCallHandler(channel, (call) async {
+        if (call.method == 'status') return 'denied';
+        if (call.method == 'save') saved = true;
+        return null;
+      });
+
+      final result = await AndroidImageSaver(
+        isSupportedPlatform: true,
+        storageStatus: () async => ph.PermissionStatus.denied,
+        requestStorage: () async => ph.PermissionStatus.denied,
+      ).saveToGallery(bytes: bytes, fileName: 'dpip-earthquake-7.png');
+
+      expect(saved, isFalse);
+      expect(
+        failureOf(result)!.reason,
+        ImageSaveFailureReason.permissionDenied,
+      );
+    });
+  });
+
+  test(
+    'a write failure is reported as failed, not as a permission problem',
+    () async {
+      messenger.setMockMethodCallHandler(channel, (call) async {
+        if (call.method == 'status') return 'granted';
+        throw PlatformException(code: 'save_failed');
+      });
+
+      final result = await IosImageSaver(isSupportedPlatform: true)
+          .saveToGallery(bytes: bytes, fileName: 'dpip-earthquake-8.png');
+
+      expect(failureOf(result)!.reason, ImageSaveFailureReason.failed);
+    },
+  );
+
+  test('a missing plugin is unavailable rather than a crash', () async {
+    // No handler registered at all.
+    final result = await IosImageSaver(isSupportedPlatform: true)
+        .saveToGallery(bytes: bytes, fileName: 'dpip-earthquake-9.png');
+
+    expect(failureOf(result)!.reason, ImageSaveFailureReason.unavailable);
+  });
+
+  test('createImageSaver picks the platform saver it is told', () {
+    expect(
+      createImageSaver(isIOS: true, isAndroid: false),
+      isA<IosImageSaver>(),
+    );
+    expect(
+      createImageSaver(isIOS: false, isAndroid: true),
+      isA<AndroidImageSaver>(),
+    );
+    expect(
+      createImageSaver(isIOS: false, isAndroid: false),
+      isA<UnsupportedImageSaver>(),
+    );
+  });
+}
diff --git a/test/features/earthquake/presentation/pages/report_detail_page_test.dart b/test/features/earthquake/presentation/pages/report_detail_page_test.dart
index d0e57d242..f527462eb 100644
--- a/test/features/earthquake/presentation/pages/report_detail_page_test.dart
+++ b/test/features/earthquake/presentation/pages/report_detail_page_test.dart
@@ -17,6 +17,7 @@ import 'package:dpip/core/error/result.dart';
 import 'package:dpip/core/geo/town.dart';
 import 'package:dpip/core/geo/town_directory.dart';
 import 'package:dpip/core/network/api_client.dart';
+import 'package:dpip/core/platform/image_saver.dart';
 import 'package:dpip/core/network/region_selection.dart';
 import 'package:dpip/core/realtime/app_time.dart';
 import 'package:dpip/core/realtime/clock.dart';
@@ -363,7 +364,7 @@ void main() {
     );
   }
 
-  GoRouter nestedRouter(_Reports reports) => GoRouter(
+  GoRouter nestedRouter(_Reports reports, {ImageSaver? imageSaver}) => GoRouter(
     initialLocation: '/earthquake/115053-2026-0310-140000',
     routes: [
       GoRoute(
@@ -374,8 +375,10 @@ void main() {
           GoRoute(
             path: ':id',
             name: AppRoutes.earthquakeReport,
-            builder: (_, state) =>
-                ReportDetailPage(reportId: state.pathParameters['id']!),
+            builder: (_, state) => ReportDetailPage(
+              reportId: state.pathParameters['id']!,
+              imageSaver: imageSaver,
+            ),
             routes: [
               GoRoute(
                 path: 'replay',
@@ -586,7 +589,7 @@ void main() {
 
     // Settle, never a bare pump: the menu opens on an animation, so one frame
     // leaves every row mid-flight and a tap lands wherever it was passing.
-    await tester.tap(find.byTooltip('Township names'));
+    await tester.tap(find.byTooltip('Map settings panel'));
     await tester.pumpAndSettle();
     await tester.tap(find.text('Terrain relief'));
     await tester.pumpAndSettle();
@@ -597,7 +600,7 @@ void main() {
     await tester.tap(find.text('Township names'));
     await tester.pumpAndSettle();
     // The menu stays open over the compass; close it before tapping the needle.
-    await tester.tap(find.byTooltip('Township names'));
+    await tester.tap(find.byTooltip('Map settings panel'));
     await tester.pumpAndSettle();
 
     platform.failNextDetailSource = true;
@@ -773,6 +776,75 @@ void main() {
     await tester.pump();
     expect(find.text('Report image not available'), findsOneWidget);
   });
+
+  testWidgets('the report image saves to the photo library', (tester) async {
+    final reports = _Reports()..next = Ok(_report());
+    final settings = SettingsStore.inMemory();
+    final saver = _RecordingSaver();
+    await pumpPage(
+      tester,
+      reports: reports,
+      client: _BytesClient(RegionSelection(settings)),
+      settings: settings,
+      regions: RegionStore(settings),
+      towns: const TownDirectory({}),
+      router: nestedRouter(reports, imageSaver: saver),
+    );
+    await tester.pump();
+    await tester.pump();
+
+    await _expandSheet(tester);
+    await tester.scrollUntilVisible(find.byType(Image), 400);
+    // Image.memory decodes off the fake clock; let the real codec finish.
+    await tester.runAsync(
+      () => Future<void>.delayed(const Duration(milliseconds: 100)),
+    );
+    await tester.pump();
+    await tester.ensureVisible(find.byTooltip('Save image'));
+
+    await tester.tap(find.byTooltip('Save image'));
+    await tester.pump();
+
+    expect(saver.saved, hasLength(1));
+    expect(
+      saver.saved.single.fileName,
+      'dpip-earthquake-115053-2026-0310-140000.png',
+    );
+    expect(find.text('Saved to your photos'), findsOneWidget);
+
+    // A refusal must say so in its own words, and offer the only way out:
+    // Settings, not another tap.
+    saver.result = const Err(
+      ImageSaveFailure(ImageSaveFailureReason.permissionDenied, 'refused'),
+    );
+    await tester.tap(find.byTooltip('Save image'));
+    await tester.pump();
+
+    expect(find.text('Allow photo access to save the image'), findsOneWidget);
+    expect(find.text('Open Settings'), findsOneWidget);
+  });
+}
+
+/// Records what the save button hands over, and answers with [result].
+///
+/// The permission gate itself is covered by `image_saver_test.dart`; here it
+/// simply agrees, so the widget path is what is under test.
+class _RecordingSaver implements ImageSaver {
+  final saved = <({Uint8List bytes, String fileName})>[];
+  Result<void> result = const Ok(null);
+
+  @override
+  Future<Result<void>> ensurePermission() async => const Ok(null);
+
+  @override
+  Future<Result<void>> saveToGallery({
+    required Uint8List bytes,
+    required String fileName,
+    String mimeType = 'image/png',
+  }) async {
+    saved.add((bytes: bytes, fileName: fileName));
+    return result;
+  }
 }
 
 /// Drags the peek, not the sheet's full-screen centre (that is the map).
diff --git a/test/features/earthquake/presentation/pages/report_replay_page_test.dart b/test/features/earthquake/presentation/pages/report_replay_page_test.dart
index 243a8429f..c64d718bd 100644
--- a/test/features/earthquake/presentation/pages/report_replay_page_test.dart
+++ b/test/features/earthquake/presentation/pages/report_replay_page_test.dart
@@ -41,6 +41,7 @@ import 'package:dpip/features/earthquake/domain/seismic_travel_time.dart';
 import 'package:dpip/features/earthquake/domain/trem_station_repository.dart';
 import 'package:dpip/features/earthquake/presentation/pages/report_replay_page.dart';
 import 'package:dpip/l10n/gen/app_localizations.dart';
+import 'package:dpip/shared/map/map_immersive.dart';
 import 'package:dpip/shared/seismic/intensity_circle_renderer.dart';
 import 'package:dpip/shared/seismic/intensity_icon_renderer.dart';
 import 'package:dpip/shared/navigation/refresh_on_appear.dart';
@@ -491,6 +492,9 @@ void main() {
         MultiProvider(
           providers: [
             Provider<ApiClient>.value(value: archive),
+            ChangeNotifierProvider<MapImmersiveController>(
+              create: (_) => MapImmersiveController(),
+            ),
             Provider<RealtimeService>.value(value: realtime),
             ChangeNotifierProvider<EewCwaOnlySettings>.value(value: cwaOnly),
             ChangeNotifierProvider<EewSpokenAnnouncementSettings>.value(
@@ -606,7 +610,7 @@ void main() {
       // Settle, never a bare pump: the menu opens on an animation, so one
       // frame leaves every row mid-flight and a tap lands wherever it was
       // passing.
-      await tester.tap(find.byTooltip('Township names'));
+      await tester.tap(find.byTooltip('Map settings panel'));
       await tester.pumpAndSettle();
       await tester.tap(find.text('Detailed map'));
       await tester.pumpAndSettle();
@@ -614,7 +618,7 @@ void main() {
       await tester.pumpAndSettle();
       await tester.tap(find.text('Township names'));
       await tester.pumpAndSettle();
-      await tester.tap(find.byTooltip('Township names'));
+      await tester.tap(find.byTooltip('Map settings panel'));
       await tester.pumpAndSettle();
 
       platform.lookEast();
@@ -630,6 +634,39 @@ void main() {
       tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
       await tester.pump();
 
+      // The replay carries the same immersive chip as the map tab, and hides
+      // its own back/legend/ranking and base-map chrome while it is on.
+      expect(find.byTooltip(l10n.mapImmersive), findsOneWidget);
+      await tester.tap(find.byTooltip(l10n.mapImmersive));
+      await tester.pump();
+      expect(find.byIcon(Icons.arrow_back).hitTestable(), findsNothing);
+      expect(find.byTooltip(l10n.mapLegendExpand).hitTestable(), findsNothing);
+      expect(find.byTooltip('Map settings panel').hitTestable(), findsNothing);
+      expect(find.byTooltip(l10n.mapImmersiveExit), findsOneWidget);
+
+      await tester.pump(const Duration(milliseconds: 300));
+      await tester.tap(find.byTooltip(l10n.mapImmersiveExit));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 300));
+      expect(find.byTooltip(l10n.mapImmersiveExit), findsNothing);
+      expect(find.byIcon(Icons.arrow_back).hitTestable(), findsOneWidget);
+      expect(
+        find.byTooltip(l10n.mapLegendExpand).hitTestable(),
+        findsOneWidget,
+      );
+      expect(
+        find.byTooltip('Map settings panel').hitTestable(),
+        findsOneWidget,
+      );
+
+      // A back press belongs to the mode first: it must not pop the replay.
+      await tester.tap(find.byTooltip(l10n.mapImmersive));
+      await tester.pump();
+      await tester.binding.handlePopRoute();
+      await tester.pump();
+      expect(find.byType(ReportReplayPage), findsOneWidget);
+      expect(find.byIcon(Icons.arrow_back).hitTestable(), findsOneWidget);
+
       await tester.tap(find.byIcon(Icons.arrow_back));
       await tester.pump();
       await tester.pump();
@@ -670,6 +707,9 @@ void main() {
         MultiProvider(
           providers: [
             Provider<ApiClient>.value(value: archive),
+            ChangeNotifierProvider<MapImmersiveController>(
+              create: (_) => MapImmersiveController(),
+            ),
             Provider<RealtimeService>.value(value: realtime),
             ChangeNotifierProvider<EewCwaOnlySettings>.value(value: cwaOnly),
             ChangeNotifierProvider<EewSpokenAnnouncementSettings>.value(
@@ -747,6 +787,9 @@ void main() {
             MultiProvider(
               providers: [
                 Provider<ApiClient>.value(value: archive),
+                ChangeNotifierProvider<MapImmersiveController>(
+                  create: (_) => MapImmersiveController(),
+                ),
                 Provider<RealtimeService>.value(value: realtime),
                 ChangeNotifierProvider<EewCwaOnlySettings>.value(
                   value: cwaOnly,
@@ -847,6 +890,9 @@ void main() {
           child: MultiProvider(
             providers: [
               Provider<ApiClient>.value(value: archive),
+              ChangeNotifierProvider<MapImmersiveController>(
+                create: (_) => MapImmersiveController(),
+              ),
               Provider<RealtimeService>.value(value: realtime),
               ChangeNotifierProvider<EewCwaOnlySettings>.value(value: cwaOnly),
               ChangeNotifierProvider<EewSpokenAnnouncementSettings>.value(
diff --git a/test/features/map/presentation/map_scaffold_test.dart b/test/features/map/presentation/map_scaffold_test.dart
index ea4696878..9aee4b68e 100644
--- a/test/features/map/presentation/map_scaffold_test.dart
+++ b/test/features/map/presentation/map_scaffold_test.dart
@@ -15,6 +15,7 @@ import 'package:dpip/core/settings/setting_keys.dart';
 import 'package:dpip/core/settings/settings_store.dart';
 import 'package:dpip/l10n/gen/app_localizations.dart';
 import 'package:dpip/shared/map/map_camera_handoff.dart';
+import 'package:dpip/shared/map/map_immersive.dart';
 import 'package:dpip/shared/map/map_layer.dart';
 import 'package:dpip/shared/map/map_scaffold.dart';
 import 'package:dpip/shared/map/map_station_handoff.dart';
@@ -112,6 +113,8 @@ class _Layer with MapLayerDefaults implements MapLayer {
     required this.name,
     this.timeline = true,
     this.withChrome = false,
+    this.sheetFills = false,
+    this.sheetBottom = false,
   });
 
   @override
@@ -120,6 +123,14 @@ class _Layer with MapLayerDefaults implements MapLayer {
   final bool timeline;
   final bool withChrome;
 
+  /// Whether [buildSheet] is a full-screen, tap-absorbing panel — the state a
+  /// draggable detail sheet reaches when the user drags it to the top.
+  final bool sheetFills;
+
+  /// Whether [buildSheet] is a bottom strip inside a [SafeArea] — the shape the
+  /// RTS monitor's status bar and every sheet layer's peek use.
+  final bool sheetBottom;
+
   Result<List<MapFrame>> framesResult = const Ok([]);
   Completer<Result<List<MapFrame>>>? framesGate;
   int frameCalls = 0;
@@ -235,7 +246,22 @@ class _Layer with MapLayerDefaults implements MapLayer {
   Widget? buildLegendAccessory(BuildContext context) => const Text('Rank');
 
   @override
-  Widget buildSheet(BuildContext context) => const Text('Sheet body');
+  Widget buildSheet(BuildContext context) {
+    if (sheetBottom) {
+      return Align(
+        alignment: Alignment.bottomCenter,
+        child: SafeArea(top: false, child: const Text('Sheet bottom')),
+      );
+    }
+    if (sheetFills) {
+      return GestureDetector(
+        behavior: HitTestBehavior.opaque,
+        onTap: () {},
+        child: const SizedBox.expand(),
+      );
+    }
+    return const Text('Sheet body');
+  }
 
   @override
   Widget buildMapOverlay(BuildContext context) => const Text('Callout');
@@ -284,6 +310,24 @@ void main() {
   Future<AppLocalizations> english() =>
       AppLocalizations.delegate.load(const Locale('en'));
 
+  /// Reproduces the shell's `extendBody` contract: the nav bar's height is part
+  /// of this subtree's bottom padding, above the system inset.
+  Widget homeWithInset(Widget home, {required bool navInset}) {
+    if (!navInset) return home;
+    return Builder(
+      builder: (context) {
+        final media = MediaQuery.of(context);
+        return MediaQuery(
+          data: media.copyWith(
+            padding: media.padding.copyWith(bottom: 80),
+            viewPadding: media.viewPadding.copyWith(bottom: 24),
+          ),
+          child: home,
+        );
+      },
+    );
+  }
+
   Future<void> show(
     WidgetTester tester, {
     required SettingsStore settings,
@@ -295,6 +339,8 @@ void main() {
     bool initialOsmEnabled = false,
     VisibleTab? visibleTab,
     int? tabIndex,
+    MapImmersiveController? immersive,
+    bool navInset = false,
   }) async {
     final child = MapScaffold(
       layers: layers,
@@ -311,6 +357,9 @@ void main() {
           ChangeNotifierProvider<MapLayerVisibilityController>.value(
             value: visibility,
           ),
+          ChangeNotifierProvider<MapImmersiveController>.value(
+            value: immersive ?? MapImmersiveController(),
+          ),
           ChangeNotifierProvider<MapLayerOrderController>.value(
             value: MapLayerOrderController(settings),
           ),
@@ -323,9 +372,12 @@ void main() {
           locale: const Locale('en'),
           localizationsDelegates: AppLocalizations.localizationsDelegates,
           supportedLocales: AppLocalizations.supportedLocales,
-          home: visibleTab == null
-              ? child
-              : VisibleTabScope(visibleTab: visibleTab, child: child),
+          home: homeWithInset(
+            visibleTab == null
+                ? child
+                : VisibleTabScope(visibleTab: visibleTab, child: child),
+            navInset: navInset,
+          ),
         ),
       ),
     );
@@ -373,6 +425,195 @@ void main() {
     expect(echo.shown.length, greaterThan(1));
   });
 
+  testWidgets('immersive hides the chrome, and its chip brings it back', (
+    tester,
+  ) async {
+    final l10n = await english();
+    final immersive = MapImmersiveController();
+    final echo = _Layer(id: 'echo', name: 'Echo')
+      ..framesResult = Ok(twoFrames());
+    await show(
+      tester,
+      settings: SettingsStore.inMemory(),
+      camera: MapCameraHandoff(),
+      stations: MapStationHandoff(),
+      visibility: MapLayerVisibilityController(SettingsStore.inMemory()),
+      layers: [echo],
+      immersive: immersive,
+    );
+    await loadStyle(tester);
+
+    expect(find.byTooltip(l10n.mapImmersive), findsOneWidget);
+    expect(find.byTooltip(l10n.mapLayers), findsOneWidget);
+    expect(find.text(l10n.mapTimelineObserved), findsOneWidget);
+    expect(find.byTooltip(l10n.mapLegendExpand), findsOneWidget);
+    // It is map chrome on the filter/selector row — not inside the layers
+    // sheet — and it sits to the left of the layer selector.
+    expect(
+      tester.getTopLeft(find.byTooltip(l10n.mapImmersive)).dx,
+      lessThan(tester.getTopLeft(find.byTooltip(l10n.mapLayers)).dx),
+    );
+
+    final timelineAtRest = tester
+        .getTopLeft(find.text(l10n.mapTimelineObserved))
+        .dy;
+    await tester.tap(find.byTooltip(l10n.mapImmersive));
+    await tester.pump();
+
+    // The chrome is still painted on the first frame (it is fading), but it is
+    // already non-interactive. That is the transition, not a swap.
+    expect(find.byTooltip(l10n.mapLayers).hitTestable(), findsNothing);
+    expect(find.text(l10n.mapTimelineObserved).hitTestable(), findsNothing);
+    expect(find.byTooltip(l10n.mapLegendExpand).hitTestable(), findsNothing);
+    expect(find.byTooltip(l10n.mapImmersiveExit), findsOneWidget);
+    expect(
+      tester.getTopLeft(find.text(l10n.mapTimelineObserved)).dy,
+      closeTo(timelineAtRest, 0.01),
+    );
+
+    await tester.pump(const Duration(milliseconds: 110));
+    final midway = tester.getTopLeft(find.text(l10n.mapTimelineObserved)).dy;
+    expect(midway, greaterThan(timelineAtRest));
+    await tester.pump(const Duration(milliseconds: 200));
+    expect(
+      tester.getTopLeft(find.text(l10n.mapTimelineObserved)).dy,
+      greaterThan(midway),
+    );
+
+    await tester.tap(find.byTooltip(l10n.mapImmersiveExit));
+    await tester.pump();
+    await tester.pump(const Duration(milliseconds: 300));
+
+    expect(find.byTooltip(l10n.mapImmersiveExit), findsNothing);
+    expect(find.byTooltip(l10n.mapImmersive), findsOneWidget);
+    expect(find.byTooltip(l10n.mapLayers).hitTestable(), findsOneWidget);
+    expect(find.text(l10n.mapTimelineObserved).hitTestable(), findsOneWidget);
+    expect(find.byTooltip(l10n.mapLegendExpand).hitTestable(), findsOneWidget);
+    expect(immersive.value, isFalse);
+  });
+
+  testWidgets('the immersive exit stays tappable above a full-height sheet', (
+    tester,
+  ) async {
+    final l10n = await english();
+    final immersive = MapImmersiveController();
+    final stations = _Layer(
+      id: 'stations',
+      name: 'Stations',
+      timeline: false,
+      sheetFills: true,
+    );
+    await show(
+      tester,
+      settings: SettingsStore.inMemory(),
+      camera: MapCameraHandoff(),
+      stations: MapStationHandoff(),
+      visibility: MapLayerVisibilityController(SettingsStore.inMemory()),
+      layers: [stations],
+      immersive: immersive,
+    );
+    await loadStyle(tester);
+
+    immersive.enter();
+    await tester.pump();
+    expect(immersive.value, isTrue);
+
+    // The sheet covers the whole map, including the chip's corner. Tapping
+    // must still reach the chip: it is the only part of the mode that has to
+    // stay above the layer's own content.
+    await tester.tap(find.byTooltip(l10n.mapImmersiveExit));
+    await tester.pump();
+
+    expect(immersive.value, isFalse);
+  });
+
+  testWidgets('system back leaves immersive before it leaves the app', (
+    tester,
+  ) async {
+    final l10n = await english();
+    final immersive = MapImmersiveController();
+    final echo = _Layer(id: 'echo', name: 'Echo')
+      ..framesResult = Ok(twoFrames());
+    await show(
+      tester,
+      settings: SettingsStore.inMemory(),
+      camera: MapCameraHandoff(),
+      stations: MapStationHandoff(),
+      visibility: MapLayerVisibilityController(SettingsStore.inMemory()),
+      layers: [echo],
+      immersive: immersive,
+    );
+    await loadStyle(tester);
+
+    immersive.enter();
+    await tester.pump();
+
+    await tester.binding.handlePopRoute();
+    await tester.pump();
+    await tester.pump(const Duration(milliseconds: 300));
+
+    // The map route is the app's root: a back press there would otherwise
+    // leave DPIP. While immersive it exits the mode instead.
+    expect(immersive.value, isFalse);
+    expect(find.byTooltip(l10n.mapImmersiveExit), findsNothing);
+  });
+
+  testWidgets('the MapLibre corner ornament is pushed out of the map', (
+    tester,
+  ) async {
+    final echo = _Layer(id: 'echo', name: 'Echo')
+      ..framesResult = Ok(twoFrames());
+    await show(
+      tester,
+      settings: SettingsStore.inMemory(),
+      camera: MapCameraHandoff(),
+      stations: MapStationHandoff(),
+      visibility: MapLayerVisibilityController(SettingsStore.inMemory()),
+      layers: [echo],
+    );
+    await loadStyle(tester);
+
+    // The plugin has no hide flag for the (i) ornament; the view is moved off
+    // the platform view and tinted clear. If this regresses, the button is
+    // back in the bottom-right corner with no test failing.
+    final map = tester.widget<MapLibreMap>(find.byType(MapLibreMap));
+    expect(map.attributionButtonColor, Colors.transparent);
+    expect(map.attributionButtonMargins, const Point(-4000, -4000));
+  });
+
+  testWidgets('a sheet layer drops into the hidden nav bar space', (
+    tester,
+  ) async {
+    final immersive = MapImmersiveController();
+    final stations = _Layer(
+      id: 'stations',
+      name: 'Stations',
+      timeline: false,
+      sheetBottom: true,
+    );
+    await show(
+      tester,
+      settings: SettingsStore.inMemory(),
+      camera: MapCameraHandoff(),
+      stations: MapStationHandoff(),
+      visibility: MapLayerVisibilityController(SettingsStore.inMemory()),
+      layers: [stations],
+      immersive: immersive,
+      navInset: true,
+    );
+    await loadStyle(tester);
+
+    final before = tester.getBottomLeft(find.text('Sheet bottom')).dy;
+    immersive.enter();
+    await tester.pump();
+    await tester.pump(const Duration(milliseconds: 300));
+    final after = tester.getBottomLeft(find.text('Sheet bottom')).dy;
+
+    // The bar reserved 80 logical px above the 24 px system inset; immersive
+    // settles one spacing token above that inset, so the strip drops by 40.
+    expect(after - before, closeTo(40, 0.5));
+  });
+
   testWidgets('a failed frame list shows the message and retry reloads', (
     tester,
   ) async {
diff --git a/test/features/map/presentation/pages/map_page_test.dart b/test/features/map/presentation/pages/map_page_test.dart
index d88285f93..f8bcd2ab0 100644
--- a/test/features/map/presentation/pages/map_page_test.dart
+++ b/test/features/map/presentation/pages/map_page_test.dart
@@ -46,6 +46,7 @@ import 'package:dpip/features/weather/domain/wind_forecast_model.dart';
 import 'package:dpip/features/weather/domain/wind_forecast_repository.dart';
 import 'package:dpip/l10n/gen/app_localizations.dart';
 import 'package:dpip/shared/map/map_camera_handoff.dart';
+import 'package:dpip/shared/map/map_immersive.dart';
 import 'package:dpip/shared/map/map_station_handoff.dart';
 import 'package:dpip/shared/map/map_tile_cache.dart';
 import 'package:flutter/foundation.dart';
@@ -219,6 +220,9 @@ void main() {
           ChangeNotifierProvider<MapLayerVisibilityController>.value(
             value: visibility,
           ),
+          ChangeNotifierProvider<MapImmersiveController>(
+            create: (_) => MapImmersiveController(),
+          ),
           ChangeNotifierProvider<MapLayerOrderController>.value(
             value: MapLayerOrderController(settings),
           ),
diff --git a/test/shared/map/map_image_density_test.dart b/test/shared/map/map_image_density_test.dart
new file mode 100644
index 000000000..a50173918
--- /dev/null
+++ b/test/shared/map/map_image_density_test.dart
@@ -0,0 +1,105 @@
+/// The intensity artwork is a fixed 64px canvas, and the two platforms turn
+/// those pixels into points differently — so the same `icon-size` curve used to
+/// draw a station badge three times larger on Android. These pin the factor
+/// that cancels that out.
+library;
+
+import 'package:dpip/shared/map/map_image_density.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  /// What a [artworkPixels] icon actually renders at, in points: MapLibre
+  /// divides the image's pixels by the density the platform recorded with it
+  /// (the screen scale on iOS, a fixed 1 on Android).
+  double renderedPoints({
+    required int artworkPixels,
+    required List<Object> curve,
+    required double iconSize,
+    required double platformDivisor,
+  }) => artworkPixels * iconSize / platformDivisor;
+
+  double iconSizeAt(List<Object> curve, int zoomStop) =>
+      curve[curve.indexOf(zoomStop) + 1] as double;
+
+  test('a 3x iPhone is the reference: the factor is 1', () {
+    expect(
+      mapIconDensityFactor(isIOS: true, devicePixelRatio: 3),
+      closeTo(1.0, 1e-9),
+    );
+  });
+
+  test('an Android device always divides by 1, so the factor is 1/3', () {
+    expect(
+      mapIconDensityFactor(isIOS: false, isAndroid: true),
+      closeTo(1 / 3, 1e-9),
+    );
+  });
+
+  test('a lower-density iOS display scales the curve down with it', () {
+    expect(
+      mapIconDensityFactor(isIOS: true, devicePixelRatio: 1),
+      closeTo(1 / 3, 1e-9),
+    );
+    expect(
+      mapIconDensityFactor(isIOS: true, devicePixelRatio: 2),
+      closeTo(2 / 3, 1e-9),
+    );
+  });
+
+  test('a host with no platform keeps the artwork at its pixel size', () {
+    expect(
+      mapIconDensityFactor(isIOS: false, isAndroid: false),
+      closeTo(1.0, 1e-9),
+    );
+  });
+
+  test('the curve carries the factor', () {
+    final unscaled = intensityIconSizeCurve(1);
+    final android = intensityIconSizeCurve(1 / 3);
+
+    expect(iconSizeAt(unscaled, 5), closeTo(0.75, 1e-9));
+    expect(iconSizeAt(unscaled, 15), closeTo(1.7, 1e-9));
+    expect(iconSizeAt(android, 5), closeTo(0.25, 1e-9));
+    expect(iconSizeAt(android, 15), closeTo(1.7 / 3, 1e-9));
+  });
+
+  test('every platform now renders the badge at the same point size', () {
+    // The three cases behind the 540×960 emulator report: Android's fixed
+    // divisor, a 3x iPhone, and a 1x display.
+    final cases = <({double factor, double divisor, String name})>[
+      (
+        name: 'Android',
+        factor: mapIconDensityFactor(isIOS: false, isAndroid: true),
+        divisor: 1,
+      ),
+      (
+        name: 'iPhone 3x',
+        factor: mapIconDensityFactor(isIOS: true, devicePixelRatio: 3),
+        divisor: 3,
+      ),
+      (
+        name: '1x display',
+        factor: mapIconDensityFactor(isIOS: true, devicePixelRatio: 1),
+        divisor: 1,
+      ),
+    ];
+
+    for (final zoomStop in [5, 15]) {
+      final sizes = [
+        for (final entry in cases)
+          renderedPoints(
+            artworkPixels: 64,
+            curve: intensityIconSizeCurve(entry.factor),
+            iconSize: iconSizeAt(
+              intensityIconSizeCurve(entry.factor),
+              zoomStop,
+            ),
+            platformDivisor: entry.divisor,
+          ),
+      ];
+      for (final size in sizes) {
+        expect(sizes.first, closeTo(size, 1e-9));
+      }
+    }
+  });
+}