Merge branch 'train-maps' into integration

apps/train/halkyon_train_flutter/android/app/src/main/kotlin/app/halkyon/train/MainActivity.kt

@@ -110,6 +110,7 @@ class MainActivity : FlutterActivity() {
         "show" -> result.success(RecorderService.show(call.arguments as String).let { null })
         "isRecording" -> result.success(RecorderService.isRecording())
         "position" -> position(result)
+        "lastPosition" -> result.success(lastPosition())
         else -> result.notImplemented()
       }
     }
@@ -280,6 +281,22 @@ class MainActivity : FlutterActivity() {
     }
   }
 
+  /** Where the phone was last known to be by any provider, the newest; none without the
+   * location permission, which this never asks for (ADR 0030, D63: a new route's map opens
+   * there at once). */
+  private fun lastPosition(): Map<String, Double>? {
+    if (checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
+      checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED
+    ) {
+      return null
+    }
+    val manager = getSystemService(LocationManager::class.java)
+    val newest = manager.getProviders(true)
+      .mapNotNull { manager.getLastKnownLocation(it) }
+      .maxByOrNull { it.time }
+    return newest?.let { mapOf("lat" to it.latitude, "lon" to it.longitude) }
+  }
+
   private companion object {
     const val RECORDER_REQUEST = 1
     const val FRESH_MS = 120_000L

apps/train/halkyon_train_flutter/lib/l10n/app_de.arb

@@ -94,6 +94,10 @@
   "workoutMapOwn": "Karte von deiner Instanz, {name}, aus OpenStreetMap: sie speichert nichts vom gezeigten Ausschnitt.",
   "workoutMapSourceAbout": "Was {name} speichert",
   "workoutMapUnavailable": "Die Karte kann gerade nicht geladen werden.",
+  "workoutMapAbout": "Über die Karte",
+  "workoutShowMap": "Karte zeigen",
+  "mapCredits": "Kartennachweise",
+  "routeHelpTitle": "Eine Route planen",
   "workoutNotFound": "Dieses Training gibt es nicht mehr.",
 
   "recordHeartRate": "Herzfrequenz",

apps/train/halkyon_train_flutter/lib/l10n/app_en.arb

@@ -120,6 +120,14 @@
   "workoutMapSourceAbout": "What {name} keeps",
   "@workoutMapSourceAbout": {"description": "A link to the map source's page about what it keeps.", "placeholders": {"name": {"type": "String", "example": "OpenFreeMap"}}},
   "workoutMapUnavailable": "The map can't be loaded now.",
+  "workoutMapAbout": "About the map",
+  "@workoutMapAbout": {"description": "Title of the explanation behind the question mark on a workout's page (D63): what the map's source sees."},
+  "workoutShowMap": "Show the map",
+  "@workoutShowMap": {"description": "Tooltip of the chevron that lowers a workout's sheet, the page pulled up, so that the map shows again (D63)."},
+  "mapCredits": "Map credits",
+  "@mapCredits": {"description": "Tooltip of the button over a map that shows whose map and data it is."},
+  "routeHelpTitle": "Planning a route",
+  "@routeHelpTitle": {"description": "Title of the explanation behind the question mark over the route planner's map (D63)."},
   "workoutNotFound": "This workout is gone.",
 
   "recordHeartRate": "Heart rate",

apps/train/halkyon_train_flutter/lib/l10n/app_localizations.dart

@@ -622,6 +622,30 @@ abstract class AppLocalizations {
   /// **'The map can\'t be loaded now.'**
   String get workoutMapUnavailable;
 
+  /// Title of the explanation behind the question mark on a workout's page (D63): what the map's source sees.
+  ///
+  /// In en, this message translates to:
+  /// **'About the map'**
+  String get workoutMapAbout;
+
+  /// Tooltip of the chevron that lowers a workout's sheet, the page pulled up, so that the map shows again (D63).
+  ///
+  /// In en, this message translates to:
+  /// **'Show the map'**
+  String get workoutShowMap;
+
+  /// Tooltip of the button over a map that shows whose map and data it is.
+  ///
+  /// In en, this message translates to:
+  /// **'Map credits'**
+  String get mapCredits;
+
+  /// Title of the explanation behind the question mark over the route planner's map (D63).
+  ///
+  /// In en, this message translates to:
+  /// **'Planning a route'**
+  String get routeHelpTitle;
+
   /// No description provided for @workoutNotFound.
   ///
   /// In en, this message translates to:

apps/train/halkyon_train_flutter/lib/l10n/app_localizations_de.dart

@@ -344,6 +344,18 @@ class AppLocalizationsDe extends AppLocalizations {
   String get workoutMapUnavailable =>
       'Die Karte kann gerade nicht geladen werden.';
 
+  @override
+  String get workoutMapAbout => 'Über die Karte';
+
+  @override
+  String get workoutShowMap => 'Karte zeigen';
+
+  @override
+  String get mapCredits => 'Kartennachweise';
+
+  @override
+  String get routeHelpTitle => 'Eine Route planen';
+
   @override
   String get workoutNotFound => 'Dieses Training gibt es nicht mehr.';
 

apps/train/halkyon_train_flutter/lib/l10n/app_localizations_en.dart

@@ -341,6 +341,18 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get workoutMapUnavailable => 'The map can\'t be loaded now.';
 
+  @override
+  String get workoutMapAbout => 'About the map';
+
+  @override
+  String get workoutShowMap => 'Show the map';
+
+  @override
+  String get mapCredits => 'Map credits';
+
+  @override
+  String get routeHelpTitle => 'Planning a route';
+
   @override
   String get workoutNotFound => 'This workout is gone.';
 

apps/train/halkyon_train_flutter/lib/src/app/train_paths.dart

@@ -1,8 +1,8 @@
 import 'package:halkyon_train_flutter/src/feature/day/model/day.dart';
 
-/// The app's locations (ADR 0030, D60): the five tabs, a workout's page in
+/// The app's locations (ADR 0030, D60): the five tabs, a day's page in
-/// Home and a day's in Profile, and the editors and the recording over the
+/// Profile, and a workout's page (D63), the editors and the recording over
-/// tabs, and Settings.
+/// the tabs, and Settings.
 abstract final class TrainPaths() {
   /// Home, where the app opens: the workouts.
   static const home = '/';
@@ -19,7 +19,7 @@ abstract final class TrainPaths() {
   /// Profile: the days.
   static const profile = '/profile';
 
-  /// A workout's page, in Home.
+  /// A workout's page, in Home, over the tabs (D63).
   static String workout(String id) => '/workouts/$id';
 
   /// The page of the day [date], in Profile, by the band's name for it.

apps/train/halkyon_train_flutter/lib/src/app/train_router.dart

@@ -16,14 +16,19 @@ import 'package:halkyon_train_flutter/src/tabs/profile_tab.dart';
 import 'package:halkyon_train_flutter/src/tabs/record_tab.dart';
 import 'package:halkyon_train_flutter/src/tabs/train_shell.dart';
 import 'package:halkyon_ui/halkyon_ui.dart';
+import 'package:material_ui/material_ui.dart';
 
 /// The router of one person's app (ADR 0030, D60), as Learn's: the five tabs
-/// in a shell, each with its own stack of screens, and the editors and the
+/// in a shell, each with its own stack of screens, and the editors, the
-/// recording over them. Every route is built inside the person's scope, so
+/// recording and a workout's page, in Home, over them (D63). Every route is built inside the person's scope, so
 /// screens read their repositories from `PersonScope`. A route or plan is
 /// handed to its editor as it is (`extra`): a new one exists nowhere else
 /// yet.
-GoRouter buildTrainRouter() => GoRouter(
+GoRouter buildTrainRouter() => _router(GlobalKey());
+
+/// The router, its navigator over the shell [root].
+GoRouter _router(GlobalKey<NavigatorState> root) => GoRouter(
+  navigatorKey: root,
   routes: [
     StatefulShellRoute(
       builder: (context, state, shell) => TrainShell(shell: shell),
@@ -38,8 +43,11 @@ GoRouter buildTrainRouter() => GoRouter(
               path: TrainPaths.home,
               builder: (context, state) => const HomeTab(),
               routes: [
+                // In Home, so that back leads there, but over the shell,
+                // its map to the foot of the screen (D63).
                 GoRoute(
                   path: 'workouts/:id',
+                  parentNavigatorKey: root,
                   builder: (context, state) =>
                       workoutPage(context, state.pathParameters['id']!),
                 ),

apps/train/halkyon_train_flutter/lib/src/feature/map/data/map_style.dart

@@ -21,3 +21,39 @@ Map<String, String>? tileHeadersOf(MapSource source) =>
       final key? => {'authorization': 'Bearer $key'},
       null => null,
     };
+
+/// [style] (a MapLibre style's JSON) naming places in [language] (ADR 0030,
+/// D63): where its labels ask for the English name (`name_en`, as
+/// OpenFreeMap's styles do), the name in [language] (OpenMapTiles'
+/// `name:<language>`) instead, the name on the spot where there is none, as
+/// before. English, and a style asking for no English name (the instance's
+/// own, named in its language by its server, D50), stay as they are.
+Map<String, Object?> labelledIn(Map<String, Object?> style, String language) {
+  if (language == 'en') {
+    return style;
+  }
+  final name = 'name:$language';
+  Object? relabel(Object? value) => switch (value) {
+    'name_en' => name,
+    final String text => text.replaceAll('{name_en}', '{$name}'),
+    final List<Object?> list => [for (final item in list) relabel(item)],
+    final Map<String, Object?> map => {
+      for (final MapEntry(:key, value: item) in map.entries) key: relabel(item),
+    },
+    _ => value,
+  };
+  return {
+    ...style,
+    if (style['layers'] case final List<Object?> layers)
+      'layers': [
+        for (final layer in layers)
+          switch (layer) {
+            {'layout': final Map<String, Object?> layout} => {
+              ...layer as Map<String, Object?>,
+              'layout': relabel(layout),
+            },
+            _ => layer,
+          },
+      ],
+  };
+}

apps/train/halkyon_train_flutter/lib/src/feature/map/data/track_camera.dart

@@ -0,0 +1,59 @@
+import 'package:flutter/painting.dart';
+import 'package:latlong2/latlong.dart';
+
+/// How high the round buttons over a workout's map stand (ADR 0030, D63):
+/// the app bar's height, which they turn into.
+const trackButtonsHeight = 56.0;
+
+/// The margin kept around the track where it is fitted.
+const trackFitMargin = 32.0;
+
+/// How much of the map a track is fitted into at least, however far the
+/// sheet is pulled up.
+const minimumTrackRoom = 96.0;
+
+/// From how far up the sheet is pulled (of the page's height) the round
+/// buttons over the map fold into the app bar.
+const trackBarFrom = 0.85;
+
+/// The room left around the track on a map [view] large (D63): below the
+/// status bar ([top]) and the buttons, above the sheet covering [covered]
+/// of its foot, with [trackFitMargin] around; never less than
+/// [minimumTrackRoom] high, the sheet's side giving way.
+EdgeInsets trackFitPadding({
+  required Size view,
+  required double top,
+  required double covered,
+}) {
+  final above = top + trackButtonsHeight + trackFitMargin;
+  final below = covered + trackFitMargin;
+  final most = view.height - above - minimumTrackRoom;
+  return EdgeInsets.fromLTRB(
+    trackFitMargin,
+    above,
+    trackFitMargin,
+    below.clamp(0, most < 0 ? 0 : most),
+  );
+}
+
+/// A camera: where it looks and how close.
+typedef CameraAt = ({LatLng center, double zoom});
+
+/// The camera [t] (0 to 1) of the way from [from] to [to], as the map moves
+/// to fit the track anew once the sheet settles.
+CameraAt cameraBetween(CameraAt from, CameraAt to, double t) => switch (t) {
+  <= 0 => from,
+  >= 1 => to,
+  _ => (
+    center: LatLng(
+      from.center.latitude + (to.center.latitude - from.center.latitude) * t,
+      from.center.longitude + (to.center.longitude - from.center.longitude) * t,
+    ),
+    zoom: from.zoom + (to.zoom - from.zoom) * t,
+  ),
+};
+
+/// How far the app bar has come in (0 to 1) with the sheet pulled up to
+/// [extent] of the page: none below [trackBarFrom], all at the top.
+double barShown(double extent) =>
+    ((extent - trackBarFrom) / (1 - trackBarFrom)).clamp(0, 1).toDouble();

apps/train/halkyon_train_flutter/lib/src/feature/map/widget/map_tiles.dart

@@ -1,9 +1,12 @@
 import 'dart:typed_data';
 
-import 'package:flutter/material.dart';
+import 'package:flutter_map/flutter_map.dart';
 import 'package:halkyon_train_client/halkyon_train_client.dart' show MapSource;
+import 'package:halkyon_train_flutter/l10n/app_localizations.dart';
 import 'package:halkyon_train_flutter/src/feature/map/data/map_style.dart';
 import 'package:halkyon_train_flutter/src/feature/map/data/offline_maps.dart';
+import 'package:lucide_icons_flutter/lucide_icons.dart';
+import 'package:material_ui/material_ui.dart';
 import 'package:vector_map_tiles/vector_map_tiles.dart';
 import 'package:vector_tile_renderer/vector_tile_renderer.dart'
     show SpriteIndexReader, ThemeReader;
@@ -52,7 +55,8 @@ Future<Style> _keptStyle(
   final sprite = style.spriteIndex;
   final image = style.spriteImage;
   return Style(
-    theme: ThemeReader().read(style.json),
+    // Its places named in the app's language (D63).
+    theme: ThemeReader().read(labelledIn(style.json, language)),
     providers: TileProviders({
       for (final MapEntry(:key, :value) in style.sources.entries)
         key: _KeptFirst(maps, key, value, tileHeadersOf(source)),
@@ -137,3 +141,32 @@ class _VectorTilesState() extends State<_VectorTiles> {
     },
   );
 }
+
+/// [source]'s credit over a map, folded into a button, as it is longer than
+/// a phone is wide; open, on the theme's surface in the theme's colours,
+/// readable in either (ADR 0030, D63: flutter_map's own, built on
+/// `flutter/material`, never sees the app's theme, which is `material_ui`'s,
+/// and put the theme's text on the fallback theme's white).
+Widget mapAttribution(BuildContext context, MapSource source) {
+  final scheme = Theme.of(context).colorScheme;
+  final text = TextStyle(color: scheme.onSurface);
+  return DefaultTextStyle.merge(
+    style: text,
+    child: RichAttributionWidget(
+      popupBackgroundColor: scheme.surfaceContainerHigh,
+      openButton: (context, open) => IconButton.filledTonal(
+        tooltip: AppLocalizations.of(context).mapCredits,
+        icon: const Icon(LucideIcons.info),
+        onPressed: open,
+      ),
+      closeButton: (context, close) => IconButton(
+        tooltip: MaterialLocalizations.of(context).closeButtonTooltip,
+        icon: Icon(LucideIcons.x, color: scheme.onSurface),
+        onPressed: close,
+      ),
+      attributions: [
+        TextSourceAttribution(source.attribution, textStyle: text),
+      ],
+    ),
+  );
+}

apps/train/halkyon_train_flutter/lib/src/feature/recording/data/android_recorder_platform.dart

@@ -98,6 +98,13 @@ class AndroidRecorderPlatform() implements RecorderPlatform {
         _ => null,
       };
 
+  @override
+  Future<({double lat, double lon})?> lastPosition() async =>
+      switch (await _channel.invokeMapMethod<String, double>('lastPosition')) {
+        {'lat': final lat, 'lon': final lon} => (lat: lat, lon: lon),
+        _ => null,
+      };
+
   @override
   Stream<String> lines() => _lines.receiveBroadcastStream().cast<String>();
 

apps/train/halkyon_train_flutter/lib/src/feature/recording/data/recorder_platform.dart

@@ -154,6 +154,12 @@ abstract interface class RecorderPlatform() {
   /// the location permission ([ask] first) or a fix within 15 s.
   Future<({double lat, double lon})?> position();
 
+  /// Where the phone was last known to be, by any of its ways of telling,
+  /// at once and however long ago; null without the location permission
+  /// (never asked for here) or where none is known (ADR 0030, D63: a new
+  /// route's map opens there while [position] waits for a fix).
+  Future<({double lat, double lon})?> lastPosition();
+
   /// Every line of the file written so far, then each new one as it is
   /// written, while a recording runs.
   Stream<String> lines();

apps/train/halkyon_train_flutter/lib/src/feature/recording/widget/recording_screen.dart

@@ -586,9 +586,7 @@ class _RecordingMapState() extends State<_RecordingMap> {
                   ],
                 ),
               if (snapshot.data case final source?)
-                RichAttributionWidget(
+                mapAttribution(context, source),
-                  attributions: [TextSourceAttribution(source.attribution)],
-                ),
             ],
           ),
           if (live.route case final route?)

apps/train/halkyon_train_flutter/lib/src/feature/route/widget/route_screen.dart

@@ -1,3 +1,5 @@
+import 'dart:async';
+
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:flutter_map/flutter_map.dart';
 import 'package:go_router/go_router.dart';
@@ -21,6 +23,8 @@ import 'package:halkyon_train_flutter/src/feature/route/widget/route_import.dart
 import 'package:halkyon_train_flutter/src/feature/route/widget/route_texts.dart';
 import 'package:halkyon_train_flutter/src/feature/workout/data/workout_analysis.dart'
     show ChartPoint;
+import 'package:halkyon_train_flutter/src/feature/workout/data/workout_repository.dart';
+import 'package:halkyon_train_flutter/src/feature/workout/data/workout_start.dart';
 import 'package:halkyon_train_flutter/src/feature/workout/model/workout.dart';
 import 'package:halkyon_train_flutter/src/feature/workout/widget/workout_chart.dart';
 import 'package:halkyon_train_flutter/src/feature/workout/widget/workout_texts.dart';
@@ -66,10 +70,29 @@ Widget routePage(BuildContext context, RouteContent route, {String? id}) {
         create: (context) => PlaceSearchCubit(train.placeSearch)..open(),
       ),
     ],
-    child: RouteScreen(maps: train.maps.source()),
+    child: RouteScreen(
+      maps: train.maps.source(),
+      // Only a new route's map opens near the person; a stored one fits it.
+      near: route.waypoints.isEmpty
+          ? _near(platform, train.workouts)
+          : Future.value(),
+    ),
   );
 }
 
+/// Where a new route's map opens at once (ADR 0030, D63): where the phone
+/// was last known to be, else where the newest workout with a track
+/// started; null where neither is known, the map then showing the region.
+Future<LatLng?> _near(
+  RecorderPlatform? platform,
+  WorkoutRepository workouts,
+) async {
+  if (await platform?.lastPosition() case (:final lat, :final lon)) {
+    return LatLng(lat, lon);
+  }
+  return await lastWorkoutStart(workouts);
+}
+
 /// Where the phone is, the location permission asked for first.
 Future<LatLng?> _here(RecorderPlatform platform) async {
   if (!(await platform.ask({
@@ -89,8 +112,11 @@ Future<LatLng?> _here(RecorderPlatform platform) async {
 /// under it the route's name, what it is for and its profile, and the way
 /// planned: its distance, climb and descent, its elevation and its
 /// surfaces. Saved with the button, deleted after asking.
-class const RouteScreen({required final Future<MapSource?> maps, super.key})
+class const RouteScreen({
-    extends StatelessWidget {
+  required final Future<MapSource?> maps,
+  final Future<LatLng?>? near,
+  super.key,
+}) extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     final l10n = AppLocalizations.of(context);
@@ -130,24 +156,37 @@ class const RouteScreen({required final Future<MapSource?> maps, super.key})
           ],
         ),
         body: SafeArea(
-          child: Column(
+          child: Builder(
-            children: [
+            builder: (context) {
-              Expanded(
+              final map = FutureBuilder(
-                flex: 3,
-                child: FutureBuilder(
                 future: maps,
                 builder: (context, snapshot) => switch (snapshot) {
                   AsyncSnapshot(:final MapSource data) => _RouteMap(
                     source: data,
+                    near: near,
                   ),
                   AsyncSnapshot(connectionState: ConnectionState.done) =>
                     Center(child: Text(l10n.workoutMapUnavailable)),
                   _ => const Center(child: AppLoadingIndicator()),
                 },
-                ),
+              );
-              ),
+              // From expanded windows on, the details beside the map, as
+              // Material's supporting pane (D63).
+              return context.windowSize.isAtLeastExpanded
+                  ? Row(
+                      crossAxisAlignment: CrossAxisAlignment.stretch,
+                      children: [
+                        Expanded(child: map),
+                        const SizedBox(width: 400, child: _Details()),
+                      ],
+                    )
+                  : Column(
+                      children: [
+                        Expanded(flex: 3, child: map),
                         const Expanded(flex: 2, child: _Details()),
                       ],
+                    );
+            },
           ),
         ),
       ),
@@ -197,8 +236,10 @@ class const RouteScreen({required final Future<MapSource?> maps, super.key})
 /// offers to take it off, the button above takes the last off, and a place searched for and chosen is the
 /// next (D50). The camera fits the route as it opens, and
 /// goes to a new route's first waypoint once it is known.
-class const _RouteMap({required final MapSource source})
+class const _RouteMap({
-    extends StatefulWidget {
+  required final MapSource source,
+  final Future<LatLng?>? near,
+}) extends StatefulWidget {
   @override
   State<_RouteMap> createState() => _RouteMapState();
 }
@@ -220,11 +261,38 @@ class _RouteMapState() extends State<_RouteMap> {
   /// What the camera fits as the map opens: the route as it was opened.
   late final List<LatLng> _fit;
 
+  /// Whether the map is drawn, so that its camera can be moved.
+  var _ready = false;
+
+  /// Where a new route's map goes as it opens, once known (D63).
+  LatLng? _near;
+
   @override
   void initState() {
     super.initState();
     final route = context.read<RouteEditorCubit>().state.route;
     _fit = [...?route.planned?.points, ...route.waypoints];
+    unawaited(
+      widget.near?.then((near) {
+        if (mounted) {
+          _near = near;
+          _goNear();
+        }
+      }),
+    );
+  }
+
+  /// Closer, near the person, while the map still shows the region and no
+  /// waypoint is set: zoom 14, a town's district, as a map app opens on
+  /// where one is.
+  void _goNear() {
+    final near = _near;
+    if (_ready &&
+        near != null &&
+        context.read<RouteEditorCubit>().state.route.waypoints.isEmpty &&
+        _map.camera.zoom < 10) {
+      _map.move(near, 14);
+    }
   }
 
   @override
@@ -251,9 +319,6 @@ class _RouteMapState() extends State<_RouteMap> {
       },
       builder: (context, state) {
         final route = state.route;
-        final searches = context.select<PlaceSearchCubit, bool>(
-          (search) => search.state.offered ?? false,
-        );
         final waypoints = [
           for (final (index, point) in route.waypoints.indexed) ...[
             if (_pulled case (final pulled, final at) when pulled == index) at,
@@ -283,6 +348,10 @@ class _RouteMapState() extends State<_RouteMap> {
                   flags: InteractiveFlag.all & ~InteractiveFlag.rotate,
                 ),
                 onTap: (_, point) => cubit().add(point),
+                onMapReady: () {
+                  _ready = true;
+                  _goNear();
+                },
               ),
               children: [
                 train.mapTiles(widget.source),
@@ -339,11 +408,7 @@ class _RouteMapState() extends State<_RouteMap> {
                       ),
                   ],
                 ),
-                RichAttributionWidget(
+                mapAttribution(context, widget.source),
-                  attributions: [
-                    TextSourceAttribution(widget.source.attribution),
-                  ],
-                ),
               ],
             ),
             if (state.planning)
@@ -356,27 +421,31 @@ class _RouteMapState() extends State<_RouteMap> {
             Positioned(
               top: 8,
               right: 8,
-              child: IconButton.filledTonal(
+              child: Column(
+                children: [
+                  IconButton.filledTonal(
                     tooltip: l10n.routeUndo,
                     icon: const Icon(LucideIcons.undo2),
                     onPressed: route.waypoints.isEmpty
                         ? null
                         : () => cubit().undo(),
                   ),
+                  // How the map is used, one tap away rather than over it
+                  // (D63).
+                  DecoratedBox(
+                    decoration: BoxDecoration(
+                      shape: BoxShape.circle,
+                      color: Theme.of(context).colorScheme.secondaryContainer,
                     ),
-            if (route.waypoints.length < 2 && state.offered != false)
+                    child: HelpButton(
-              Positioned(
+                      l10n.routeTapHint,
-                left: 16,
+                      title: l10n.routeHelpTitle,
-                right: 64,
-                top: searches ? 72 : 12,
-                child: Card(
-                  child: Padding(
-                    padding: const EdgeInsets.all(12),
-                    child: Text(l10n.routeTapHint),
                     ),
                   ),
+                ],
               ),
-            // Last, so that the places found lie over the hint.
+            ),
+            // Last, so that the places found lie over the map's buttons.
             Positioned(
               left: 8,
               right: 64,

apps/train/halkyon_train_flutter/lib/src/feature/route/widget/routes_map.dart

@@ -97,10 +97,7 @@ class _RoutesMapState() extends State<RoutesMap> {
               ],
             ),
           ),
-          if (snapshot.data case final source?)
+          if (snapshot.data case final source?) mapAttribution(context, source),
-            RichAttributionWidget(
-              attributions: [TextSourceAttribution(source.attribution)],
-            ),
         ],
       ),
     );

apps/train/halkyon_train_flutter/lib/src/feature/workout/data/workout_start.dart

@@ -0,0 +1,31 @@
+import 'package:halkyon_train_flutter/src/feature/workout/data/workout_repository.dart';
+import 'package:halkyon_train_flutter/src/feature/workout/model/series_chunk.dart';
+import 'package:latlong2/latlong.dart';
+
+/// How many of the newest workouts are looked into for a track.
+const _looked = 5;
+
+/// Where the newest of the person's workouts with a track started, at its
+/// first fix (ADR 0030, D63): where a new route's map opens when the phone
+/// can't say where it is; null where none of the newest has a track.
+Future<LatLng?> lastWorkoutStart(WorkoutRepository workouts) async {
+  final newest = [
+    for (final stored in await workouts.all())
+      if (stored.content case final content?) (stored.id, content.startedAt),
+  ]..sort((a, b) => b.$2.compareTo(a.$2));
+  for (final (id, _) in newest.take(_looked)) {
+    for (final chunk in await workouts.series(id)) {
+      if (chunk.kind != SeriesKind.position) {
+        continue;
+      }
+      final lats = chunk.columns['lat'] ?? const [];
+      final lons = chunk.columns['lon'] ?? const [];
+      for (var i = 0; i < lats.length && i < lons.length; i++) {
+        if ((lats[i], lons[i]) case (final lat?, final lon?)) {
+          return LatLng(lat / 1e7, lon / 1e7);
+        }
+      }
+    }
+  }
+  return null;
+}

apps/train/halkyon_train_flutter/lib/src/feature/workout/widget/workout_screen.dart

@@ -1,3 +1,7 @@
+import 'dart:async';
+import 'dart:math' as math;
+
+import 'package:flutter/foundation.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:flutter_map/flutter_map.dart';
 import 'package:go_router/go_router.dart';
@@ -6,9 +10,9 @@ import 'package:halkyon_train_client/halkyon_train_client.dart' show MapSource;
 import 'package:halkyon_train_flutter/l10n/app_localizations.dart';
 import 'package:halkyon_train_flutter/src/app/train_dependencies.dart';
 import 'package:halkyon_train_flutter/src/app/train_paths.dart';
+import 'package:halkyon_train_flutter/src/feature/map/data/track_camera.dart';
 import 'package:halkyon_train_flutter/src/feature/map/widget/map_tiles.dart';
 import 'package:halkyon_train_flutter/src/feature/plan/widget/plan_texts.dart';
-import 'package:halkyon_train_flutter/src/feature/recording/model/recording.dart';
 import 'package:halkyon_train_flutter/src/feature/recording/widget/recording_texts.dart';
 import 'package:halkyon_train_flutter/src/feature/strength/widget/workout_strength_view.dart';
 import 'package:halkyon_train_flutter/src/feature/weather/widget/workout_weather_view.dart';
@@ -40,11 +44,17 @@ Widget workoutPage(BuildContext context, String id) {
   );
 }
 
-/// A workout's page (ADR 0030, D24): its track on the instance's map, top,
+/// A workout's page (ADR 0030, D24, D63), over the tabs: with a track on the
-/// where it has one; below its name, when it was, its totals, its notes, its
+/// instance's map, the map to the foot of the screen and the rest on a sheet
-/// splits and its charts. Edit names it and writes its notes; Export hands
+/// over it, as Strava's: pulled down, the map is larger; pulled up, the
-/// it on as GPX, TCX or FIT (D49), where the device hands files on; Delete
+/// round buttons over the map fold into an app bar; settled, the map fits the
-/// asks first, goes back home and offers to undo it there.
+/// track anew into what the sheet leaves of it. From expanded windows on,
+/// the map and the rest side by side. Without a track, or without the map,
+/// the rest alone. Below the name, when it was, its totals, its notes, its
+/// splits and its charts; what the map's source sees one tap away. Edit
+/// names it and writes its notes; Export hands it on as GPX, TCX or FIT
+/// (D49), where the device hands files on; Delete asks first, goes back
+/// home and offers to undo it there.
 class const WorkoutScreen({super.key}) extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
@@ -53,48 +63,92 @@ class const WorkoutScreen({super.key}) extends StatelessWidget {
       builder: (context, state) {
         final content = state.content;
         final analysis = state.analysis;
-        return Scaffold(
+        final title = content == null ? '' : workoutTitle(l10n, content);
-          appBar: AppBar(
+        final actions = content == null
-            title: Text(content == null ? '' : workoutTitle(l10n, content)),
+            ? const <_Action>[]
+            : _actions(context, content, analysis);
+        AppBar bar() => AppBar(
+          title: Text(title),
           actions: [
-              if (content != null) ...[
+            for (final action in actions)
               IconButton(
+                tooltip: action.tooltip,
+                icon: Icon(action.icon),
+                onPressed: action.onPressed,
+              ),
+          ],
+        );
+        return switch ((state.phase, content, analysis, state.map)) {
+          (
+            WorkoutPhase.loaded,
+            final content?,
+            final analysis?,
+            MapFrom(:final source),
+          )
+              when analysis.track.isNotEmpty =>
+            context.windowSize.isAtLeastExpanded
+                ? Scaffold(
+                    appBar: bar(),
+                    body: _SidePane(
+                      content: content,
+                      analysis: analysis,
+                      source: source,
+                    ),
+                  )
+                : _MapPage(
+                    title: title,
+                    actions: actions,
+                    content: content,
+                    analysis: analysis,
+                    source: source,
+                  ),
+          (WorkoutPhase.loaded, final content?, final analysis?, final map) =>
+            Scaffold(
+              appBar: bar(),
+              body: _Plain(content: content, analysis: analysis, map: map),
+            ),
+          (WorkoutPhase.gone, _, _, _) => Scaffold(
+            appBar: bar(),
+            body: Center(child: Text(l10n.workoutNotFound)),
+          ),
+          _ => Scaffold(
+            appBar: bar(),
+            body: const Center(child: AppLoadingIndicator()),
+          ),
+        };
+      },
+    );
+  }
+
+  /// Edit, Export where the device hands files on, and Delete.
+  List<_Action> _actions(
+    BuildContext context,
+    WorkoutContent content,
+    WorkoutAnalysis? analysis,
+  ) {
+    final l10n = AppLocalizations.of(context);
+    return [
+      (
         tooltip: l10n.workoutEdit,
-                  icon: const Icon(LucideIcons.pencil),
+        icon: LucideIcons.pencil,
         onPressed: () => _edit(context, content),
       ),
       if (PersonScope.of<TrainPerson>(context).routeFiles != null)
-                  IconButton(
+        (
           tooltip: l10n.workoutExport,
-                    icon: const Icon(LucideIcons.share2),
+          icon: LucideIcons.share2,
           onPressed: () => _export(
             context,
             content,
             located: analysis?.track.isNotEmpty ?? false,
           ),
         ),
-                IconButton(
+      (
         tooltip: l10n.workoutDelete,
-                  icon: const Icon(LucideIcons.trash2),
+        icon: LucideIcons.trash2,
         onPressed: () => _delete(context),
       ),
-              ],
+    ];
-            ],
-          ),
-          body: switch ((state.phase, content, analysis)) {
-            (WorkoutPhase.loaded, final content?, final analysis?) => _Workout(
-              content: content,
-              analysis: analysis,
-              map: state.map,
-            ),
-            (WorkoutPhase.gone, _, _) => Center(
-              child: Text(l10n.workoutNotFound),
-            ),
-            _ => const Center(child: AppLoadingIndicator()),
-          },
-        );
-      },
-    );
   }
 
   Future<void> _edit(BuildContext context, WorkoutContent content) async {
@@ -194,22 +248,363 @@ Future<void> _bringInTrack(BuildContext context) async {
   }
 }
 
-/// The page under the app bar: the map fixed at the top, the rest scrolling
+/// A button of the page's: its tooltip, its icon and what it does.
-/// beneath it.
+typedef _Action = ({String tooltip, IconData icon, VoidCallback onPressed});
-class const _Workout({
+
+/// How far up the sheet starts and snaps back to, of the page's height
+/// (D63): the map above it, as Strava's opens.
+const _sheetStart = 0.55;
+
+/// How far down the sheet goes: its name and when it was still showing.
+const _sheetLowest = 0.15;
+
+/// The workout's points on the map, a piece between each pause.
+List<List<LatLng>> _piecesOf(WorkoutAnalysis analysis) => [
+  for (final piece in analysis.track)
+    [for (final fix in piece) LatLng(fix.latE7 / 1e7, fix.lonE7 / 1e7)],
+];
+
+/// The page on a phone or a tablet, with a track (D63): the map to the foot,
+/// the sheet over it, the buttons over the map folding into an app bar as
+/// the sheet comes up, the map fitting the track anew once it settles.
+class const _MapPage({
+  required final String title,
+  required final List<_Action> actions,
+  required final WorkoutContent content,
+  required final WorkoutAnalysis analysis,
+  required final MapSource source,
+}) extends StatefulWidget {
+  @override
+  State<_MapPage> createState() => _MapPageState();
+}
+
+class _MapPageState()
+    extends State<_MapPage>
+    with SingleTickerProviderStateMixin {
+  final _map = MapController();
+  final _sheet = DraggableScrollableController();
+
+  /// How far up the sheet is, of the page's height.
+  final _extent = ValueNotifier(_sheetStart);
+
+  /// The camera's way to the track fitted anew.
+  late final AnimationController _move =
+      AnimationController(
+        vsync: this,
+        duration: const Duration(milliseconds: 450),
+      )..addListener(() {
+        final to = _to;
+        final from = _from;
+        if (to != null && from != null) {
+          final at = cameraBetween(
+            from,
+            to,
+            Curves.easeInOutCubic.transform(_move.value),
+          );
+          _map.move(at.center, at.zoom);
+        }
+      });
+  CameraAt? _from;
+  CameraAt? _to;
+
+  /// Waits for the sheet to settle before the map moves.
+  Timer? _settle;
+
+  late final _pieces = _piecesOf(widget.analysis);
+  late final _all = [for (final piece in _pieces) ...piece];
+
+  @override
+  void dispose() {
+    _settle?.cancel();
+    _move.dispose();
+    _extent.dispose();
+    _sheet.dispose();
+    _map.dispose();
+    super.dispose();
+  }
+
+  /// How high the sheet goes at most: to the app bar's foot.
+  double _highest(Size view, double top) =>
+      (view.height - top - trackButtonsHeight) / view.height;
+
+  /// The track fitted into what the sheet at [extent] leaves of the map.
+  EdgeInsets _padding(Size view, double top, double extent) =>
+      trackFitPadding(view: view, top: top, covered: extent * view.height);
+
+  bool _moved(DraggableScrollableNotification notification) {
+    _extent.value = notification.extent;
+    _settle?.cancel();
+    _settle = Timer(const Duration(milliseconds: 200), _refit);
+    return false;
+  }
+
+  /// Moves the camera, eased, to fit the track into the map left free.
+  void _refit() {
+    if (!mounted || _all.length < 2) {
+      return;
+    }
+    final view = MediaQuery.sizeOf(context);
+    final top = MediaQuery.paddingOf(context).top;
+    if (_extent.value >= _highest(view, top) - 0.01) {
+      // The sheet covers the map: nothing to see moving.
+      return;
+    }
+    final camera = _map.camera;
+    final fitted = CameraFit.coordinates(
+      coordinates: _all,
+      padding: _padding(view, top, _extent.value),
+      maxZoom: 17,
+    ).fit(camera);
+    _from = (center: camera.center, zoom: camera.zoom);
+    _to = (center: fitted.center, zoom: fitted.zoom);
+    _move.forward(from: 0);
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final view = MediaQuery.sizeOf(context);
+    final top = MediaQuery.paddingOf(context).top;
+    final highest = _highest(view, top);
+    return Scaffold(
+      body: Stack(
+        children: [
+          Positioned.fill(
+            child: _TrackMap(
+              controller: _map,
+              pieces: _pieces,
+              source: widget.source,
+              fit: _padding(view, top, _sheetStart),
+              // The credit's button just above the sheet.
+              creditClear: _extent,
+            ),
+          ),
+          NotificationListener<DraggableScrollableNotification>(
+            onNotification: _moved,
+            child: DraggableScrollableSheet(
+              controller: _sheet,
+              initialChildSize: _sheetStart,
+              minChildSize: _sheetLowest,
+              maxChildSize: highest,
+              snap: true,
+              snapSizes: const [_sheetStart],
+              builder: (context, scroll) => Material(
+                color: theme.colorScheme.surface,
+                elevation: 1,
+                shape: const RoundedRectangleBorder(
+                  borderRadius: BorderRadius.vertical(top: Radius.circular(28)),
+                ),
+                clipBehavior: Clip.antiAlias,
+                child: Center(
+                  child: ConstrainedBox(
+                    constraints: const BoxConstraints(
+                      maxWidth: readableContentMaxWidth,
+                    ),
+                    child: ListView(
+                      controller: scroll,
+                      padding: EdgeInsets.fromLTRB(
+                        16,
+                        0,
+                        16,
+                        32 + MediaQuery.paddingOf(context).bottom,
+                      ),
+                      children: [
+                        const _Handle(),
+                        // Its name on the sheet, as Strava's, the app bar
+                        // showing it only pulled up.
+                        Text(
+                          widget.title,
+                          style: theme.textTheme.headlineSmall,
+                        ),
+                        const SizedBox(height: 8),
+                        ..._details(
+                          context,
+                          widget.content,
+                          widget.analysis,
+                          shown: widget.source,
+                        ),
+                      ],
+                    ),
+                  ),
+                ),
+              ),
+            ),
+          ),
+          Positioned(
+            top: 0,
+            left: 0,
+            right: 0,
+            child: ValueListenableBuilder(
+              valueListenable: _extent,
+              builder: (context, extent, _) => _Header(
+                shown: barShown(extent / highest),
+                title: widget.title,
+                actions: widget.actions,
+                onLower: () => _sheet.animateTo(
+                  _sheetStart,
+                  duration: const Duration(milliseconds: 300),
+                  curve: Curves.easeOutCubic,
+                ),
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+/// The sheet's grip, on top of it.
+class const _Handle() extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) => Center(
+    child: Container(
+      margin: const EdgeInsets.symmetric(vertical: 12),
+      width: 32,
+      height: 4,
+      decoration: BoxDecoration(
+        color: Theme.of(context).colorScheme.onSurfaceVariant.withValues(
+          alpha: 0.4,
+        ),
+        borderRadius: BorderRadius.circular(2),
+      ),
+    ),
+  );
+}
+
+/// The buttons over the map, round on it, folding into an app bar as the
+/// sheet comes up ([shown], 0 to 1): the bar's colour and its title come in,
+/// the buttons' rounds go, and the back arrow turns into a chevron down that
+/// lowers the sheet again.
+class const _Header({
+  required final double shown,
+  required final String title,
+  required final List<_Action> actions,
+  required final VoidCallback onLower,
+}) extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final scheme = theme.colorScheme;
+    final lowers = shown > 0.5;
+    Widget round(Widget button) => DecoratedBox(
+      decoration: BoxDecoration(
+        shape: BoxShape.circle,
+        color: scheme.surfaceContainerHigh.withValues(alpha: 1 - shown),
+      ),
+      child: button,
+    );
+    return ColoredBox(
+      color: scheme.surface.withValues(alpha: shown),
+      child: SafeArea(
+        bottom: false,
+        child: SizedBox(
+          height: trackButtonsHeight,
+          child: Row(
+            children: [
+              const SizedBox(width: 4),
+              round(
+                IconButton(
+                  tooltip: lowers
+                      ? AppLocalizations.of(context).workoutShowMap
+                      : MaterialLocalizations.of(context).backButtonTooltip,
+                  // A quarter turn: the arrow back points down.
+                  icon: Transform.rotate(
+                    angle: -math.pi / 2 * shown,
+                    child: const Icon(LucideIcons.chevronLeft),
+                  ),
+                  onPressed: lowers
+                      ? onLower
+                      : () => Navigator.of(context).maybePop(),
+                ),
+              ),
+              const SizedBox(width: 12),
+              Expanded(
+                child: Opacity(
+                  opacity: shown,
+                  child: Text(
+                    title,
+                    style: theme.textTheme.titleLarge,
+                    overflow: TextOverflow.ellipsis,
+                  ),
+                ),
+              ),
+              for (final action in actions) ...[
+                round(
+                  IconButton(
+                    tooltip: action.tooltip,
+                    icon: Icon(action.icon),
+                    onPressed: action.onPressed,
+                  ),
+                ),
+                const SizedBox(width: 4),
+              ],
+              const SizedBox(width: 4),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+/// The page from expanded windows on, with a track (D63): the map beside
+/// the rest, as Material's supporting pane.
+class const _SidePane({
+  required final WorkoutContent content,
+  required final WorkoutAnalysis analysis,
+  required final MapSource source,
+}) extends StatelessWidget {
+  static const double _paneWidth = 400;
+
+  @override
+  Widget build(BuildContext context) => SafeArea(
+    top: false,
+    child: Row(
+      crossAxisAlignment: CrossAxisAlignment.stretch,
+      children: [
+        Expanded(
+          child: Padding(
+            padding: const EdgeInsets.fromLTRB(16, 0, 0, 16),
+            child: ClipRRect(
+              borderRadius: BorderRadius.circular(16),
+              child: _TrackMap(
+                pieces: _piecesOf(analysis),
+                source: source,
+                fit: const EdgeInsets.all(trackFitMargin),
+              ),
+            ),
+          ),
+        ),
+        SizedBox(
+          width: _paneWidth,
+          child: ListView(
+            padding: const EdgeInsets.fromLTRB(16, 0, 16, 32),
+            children: _details(context, content, analysis, shown: source),
+          ),
+        ),
+      ],
+    ),
+  );
+}
+
+/// The page without a map: the rest alone, saying where the map couldn't be
+/// loaded.
+class const _Plain({
   required final WorkoutContent content,
   required final WorkoutAnalysis analysis,
   required final WorkoutMap? map,
 }) extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
-    final l10n = AppLocalizations.of(context);
-    final locale = Localizations.localeOf(context).toString();
     final theme = Theme.of(context);
-    final started = content.startedAt.toLocal();
+    return SafeArea(
-    final hasTrack = analysis.track.isNotEmpty;
+      top: false,
-    final details = ListView(
+      bottom: false,
-      // Running on beneath the floating bar, ending clear of it.
+      child: Center(
+        child: ConstrainedBox(
+          constraints: const BoxConstraints(maxWidth: readableContentMaxWidth),
+          child: ListView(
             padding: EdgeInsets.fromLTRB(
               16,
               16,
@@ -217,7 +612,39 @@ class const _Workout({
               32 + MediaQuery.paddingOf(context).bottom,
             ),
             children: [
-        if (hasTrack) ...[_MapNote(map: map), const SizedBox(height: 16)],
+              if (map is MapUnavailable && analysis.track.isNotEmpty) ...[
+                Text(
+                  AppLocalizations.of(context).workoutMapUnavailable,
+                  style: theme.textTheme.bodySmall?.copyWith(
+                    color: theme.colorScheme.onSurfaceVariant,
+                  ),
+                ),
+                const SizedBox(height: 16),
+              ],
+              ..._details(context, content, analysis),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+/// Everything on the page but the map: what it was and when, where it came
+/// from, its totals, weather, notes, sets, steps, splits and charts; what
+/// the map [shown] sees behind a question mark (D63).
+List<Widget> _details(
+  BuildContext context,
+  WorkoutContent content,
+  WorkoutAnalysis analysis, {
+  MapSource? shown,
+}) {
+  final l10n = AppLocalizations.of(context);
+  final locale = Localizations.localeOf(context).toString();
+  final theme = Theme.of(context);
+  final started = content.startedAt.toLocal();
+  final hasTrack = analysis.track.isNotEmpty;
+  return [
     Row(
       children: [
         Icon(activityIcon(content.activity)),
@@ -230,6 +657,23 @@ class const _Workout({
             style: theme.textTheme.bodyLarge,
           ),
         ),
+        if (shown != null)
+          HelpButton(
+            shown.tileKey == null
+                ? l10n.workoutMapSource(shown.name)
+                : l10n.workoutMapOwn(shown.name),
+            title: l10n.workoutMapAbout,
+            action: switch (shown.aboutUrl) {
+              final url? => (
+                label: l10n.workoutMapSourceAbout(shown.name),
+                onPressed: () => launchUrl(
+                  Uri.parse(url),
+                  mode: LaunchMode.externalApplication,
+                ),
+              ),
+              null => null,
+            },
+          ),
       ],
     ),
     if (content.origin case final origin?) ...[
@@ -269,11 +713,7 @@ class const _Workout({
     ],
     if (content.plan case final plan? when analysis.laps.isNotEmpty) ...[
       const SizedBox(height: 24),
-          _Laps(
+      _Laps(activity: content.activity, name: plan.name, laps: analysis.laps),
-            activity: content.activity,
-            name: plan.name,
-            laps: analysis.laps,
-          ),
     ],
     if (analysis.splits.isNotEmpty) ...[
       const SizedBox(height: 24),
@@ -355,58 +795,35 @@ class const _Workout({
         label: (value) => l10n.workoutClimbValue(value.round()),
       ),
     ],
-      ],
+  ];
-    );
-    // The sides kept clear; the foot not, as the page runs on beneath the
-    // navigation bar floating over it, as the tabs do.
-    return SafeArea(
-      top: false,
-      bottom: false,
-      child: Column(
-        children: [
-          if (map case MapFrom(:final source) when hasTrack)
-            SizedBox(
-              height: MediaQuery.sizeOf(context).height * 0.4,
-              child: _TrackMap(track: analysis.track, source: source),
-            ),
-          Expanded(
-            child: Center(
-              child: ConstrainedBox(
-                constraints: const BoxConstraints(
-                  maxWidth: readableContentMaxWidth,
-                ),
-                child: details,
-              ),
-            ),
-          ),
-        ],
-      ),
-    );
-  }
 }
 
 /// The track on the source's tiles, a gap at each pause, its start and end
-/// marked, the source credited; the camera fits the track.
+/// marked, the source credited; the camera fits the track, [fit] around it,
+/// and moves with [controller]. [creditClear], where given, is how far up
+/// a sheet covers the map (of its height), the credit's button kept above
+/// it.
 class const _TrackMap({
-  required final List<List<Fix>> track,
+  required final List<List<LatLng>> pieces,
   required final MapSource source,
+  required final EdgeInsets fit,
+  final MapController? controller,
+  final ValueListenable<double>? creditClear,
 }) extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     final train = PersonScope.of<TrainPerson>(context);
-    LatLng at(Fix fix) => LatLng(fix.latE7 / 1e7, fix.lonE7 / 1e7);
-    final pieces = [
-      for (final piece in track) [for (final fix in piece) at(fix)],
-    ];
     final all = [for (final piece in pieces) ...piece];
     final (start, end) = (all.first, all.last);
+    final credit = mapAttribution(context, source);
     return FlutterMap(
+      mapController: controller,
       options: MapOptions(
         maxZoom: mapMaxZoom,
         initialCameraFit: all.length > 1
             ? CameraFit.coordinates(
                 coordinates: all,
-                padding: const EdgeInsets.all(32),
+                padding: fit,
                 maxZoom: 17,
               )
             : null,
@@ -436,11 +853,19 @@ class const _TrackMap({
             _marker(end, PaletteColor.cerise.background),
           ],
         ),
-        // Folded into a button, as the credit is longer than a phone is
+        if (creditClear case final clear?)
-        // wide.
+          ValueListenableBuilder(
-        RichAttributionWidget(
+            valueListenable: clear,
-          attributions: [TextSourceAttribution(source.attribution)],
+            builder: (context, extent, child) => Padding(
+              padding: EdgeInsets.only(
+                bottom: extent * MediaQuery.sizeOf(context).height,
               ),
+              child: child,
+            ),
+            child: credit,
+          )
+        else
+          credit,
       ],
     );
   }
@@ -459,44 +884,6 @@ class const _TrackMap({
   );
 }
 
-/// What the map's source sees, and the way to its own page about that; or
-/// that the map can't be loaded.
-class const _MapNote({required final WorkoutMap? map}) extends StatelessWidget {
-  @override
-  Widget build(BuildContext context) {
-    final l10n = AppLocalizations.of(context);
-    final theme = Theme.of(context);
-    final style = theme.textTheme.bodySmall?.copyWith(
-      color: theme.colorScheme.onSurfaceVariant,
-    );
-    return switch (map) {
-      null => const SizedBox.shrink(),
-      MapUnavailable() => Text(l10n.workoutMapUnavailable, style: style),
-      MapFrom(:final source) => Column(
-        crossAxisAlignment: CrossAxisAlignment.start,
-        children: [
-          Text(
-            source.tileKey == null
-                ? l10n.workoutMapSource(source.name)
-                : l10n.workoutMapOwn(source.name),
-            style: style,
-          ),
-          if (source.aboutUrl case final url?)
-            TextButton.icon(
-              style: TextButton.styleFrom(padding: EdgeInsets.zero),
-              icon: const Icon(LucideIcons.externalLink, size: 16),
-              label: Text(l10n.workoutMapSourceAbout(source.name)),
-              onPressed: () => launchUrl(
-                Uri.parse(url),
-                mode: LaunchMode.externalApplication,
-              ),
-            ),
-        ],
-      ),
-    };
-  }
-}
-
 /// The workout's figures, each with its label beneath.
 class const _Totals({
   required final WorkoutContent content,

apps/train/halkyon_train_flutter/test/app/train_app_test.dart

@@ -56,9 +56,11 @@ import 'package:halkyon_train_flutter/src/feature/strength/model/strength_plan.d
 import 'package:halkyon_train_flutter/src/feature/weather/data/weather_gateway.dart';
 import 'package:halkyon_train_flutter/src/feature/weather/model/workout_weather.dart';
 import 'package:halkyon_train_flutter/src/feature/workout/data/workout_repository.dart';
+import 'package:halkyon_train_flutter/src/feature/workout/model/series_chunk.dart';
 import 'package:halkyon_train_flutter/src/feature/workout/model/workout.dart';
 import 'package:halkyon_train_flutter/src/feature/workout/widget/progress_cards.dart';
 import 'package:halkyon_train_flutter/src/feature/workout/widget/week_card.dart';
+import 'package:halkyon_train_flutter/src/feature/workout/widget/workout_screen.dart';
 import 'package:halkyon_train_flutter/src/tabs/maps_tab.dart';
 import 'package:halkyon_train_flutter/src/tabs/record_tab.dart';
 import 'package:halkyon_ui/halkyon_ui.dart';
@@ -289,6 +291,21 @@ void main() {
     await tester.pumpAndSettle();
   }
 
+  /// The route planner's help, behind its question mark rather than over
+  /// the map (D63): opened, read and closed.
+  Future<void> expectRouteHelp(WidgetTester tester) async {
+    const help =
+        'Tap the map to add a waypoint, tap one to take it off. Hold '
+        'one to drag it, or hold the line to pull out another.';
+    expect(find.text(help), findsNothing);
+    await tester.tap(find.byTooltip("What's this?"));
+    await tester.pumpAndSettle();
+    expect(find.text('Planning a route'), findsOneWidget);
+    expect(find.text(help), findsOneWidget);
+    await tester.tap(find.text('OK'));
+    await tester.pumpAndSettle();
+  }
+
   /// Goes to the tab [label] of the navigation bar (ADR 0030, D60).
   Future<void> goTab(WidgetTester tester, String label) async {
     await tester.tap(
@@ -2122,20 +2139,16 @@ void main() {
         await pass(tester);
         expect(find.text('Save this workout?'), findsOneWidget);
 
-        // Saved, its page opens, in Home's tab (D60).
+        // Saved, its page opens, over the tabs (D63).
         await tester.tap(find.text('Save'));
         await pass(tester, 2);
         final ride = find.textContaining(RegExp('ride', caseSensitive: false));
-        expect(
+        final page = find.byType(WorkoutScreen);
-          find.descendant(of: find.byType(AppBar), matching: ride),
+        expect(find.descendant(of: page, matching: ride), findsWidgets);
-          findsOneWidget,
+        expect(find.byType(FloatingNavigationBar), findsNothing);
-        );
         await tester.pageBack();
         await tester.pumpAndSettle();
-        expect(
+        expect(page, findsNothing);
-          find.descendant(of: find.byType(AppBar), matching: ride),
-          findsNothing,
-        );
         expect(ride, findsWidgets);
         expect(startFor(), findsNothing);
         final saved = (await workouts.all()).single.content!;
@@ -2404,7 +2417,9 @@ void main() {
           StepKind.recovery,
         ]);
 
-        // The workout, in Home.
+        // The workout, over the tabs (D63), and again from Home.
+        await tester.pageBack();
+        await tester.pumpAndSettle();
         await goTab(tester, 'Home');
         await tester.tap(find.text('0:50'));
         await tester.runAsync(pumpEventQueue);
@@ -3049,13 +3064,16 @@ void main() {
       folder.deleteSync(recursive: true);
     });
 
-    /// Maps, on a phone at [at] (null: a device that can't tell).
+    /// Maps, on a phone at [at] (null: a device that can't tell), last known
+    /// at [last], with [workouts].
     Future<void> openRoutes(
       WidgetTester tester, {
       ({double lat, double lon})? at,
+      ({double lat, double lon})? last,
       OfflineMaps? offlineMaps,
       RouteFiles? routeFiles,
       PlaceSearchGateway? placeSearch,
+      WorkoutRepository? workouts,
     }) async {
       await start(
         tester,
@@ -3065,10 +3083,13 @@ void main() {
         placeSearch: placeSearch,
         offlineMaps: offlineMaps,
         routeFiles: routeFiles,
-        recording: at == null
+        workouts: workouts,
+        recording: at == null && last == null
             ? null
             : (
-                platform: FakeRecorderPlatform()..at = at,
+                platform: FakeRecorderPlatform()
+                  ..at = at
+                  ..lastAt = last,
                 file: File('${folder.path}/recording.txt'),
                 devices: {
                   for (final kind in DeviceKind.values)
@@ -3109,13 +3130,7 @@ void main() {
       );
       await tester.tap(find.text('New route'));
       await tester.pumpAndSettle();
-      expect(
+      await expectRouteHelp(tester);
-        find.text(
-          'Tap the map to add a waypoint, tap one to take it off. Hold '
-          'one to drag it, or hold the line to pull out another.',
-        ),
-        findsOneWidget,
-      );
 
       await tester.enterText(find.byType(TextField).first, 'Tempelhof');
       // Past the pause after typing.
@@ -3154,13 +3169,7 @@ void main() {
       await tester.tap(find.text('New route'));
       await tester.pumpAndSettle();
       expect(find.text('1'), findsOneWidget);
-      expect(
+      await expectRouteHelp(tester);
-        find.text(
-          'Tap the map to add a waypoint, tap one to take it off. Hold '
-          'one to drag it, or hold the line to pull out another.',
-        ),
-        findsOneWidget,
-      );
 
       await tapMap(tester, const Offset(60, 40));
       expect(
@@ -3203,6 +3212,82 @@ void main() {
       expect(route.content?.planned, isNotNull);
     });
 
+    group("a new route's map opens near the person (D63)", () {
+      /// The planner's camera.
+      MapCamera camera(WidgetTester tester) => MapCamera.of(
+        tester.element(
+          find.descendant(
+            of: find.byType(FlutterMap),
+            matching: find.byType(MarkerLayer),
+          ),
+        ),
+      );
+
+      testWidgets('where the phone was last known, closer, before any fix', (
+        tester,
+      ) async {
+        await openRoutes(tester, last: (lat: 52.52, lon: 13.405));
+        await tester.tap(find.text('New route'));
+        await tester.pumpAndSettle();
+
+        expect(camera(tester).zoom, 14);
+        expect(camera(tester).center.latitude, closeTo(52.52, 1e-6));
+        expect(find.text('1'), findsNothing, reason: 'no waypoint set');
+      });
+
+      testWidgets('else where the newest workout with a track started', (
+        tester,
+      ) async {
+        final workouts = WorkoutRepository(MemoryWorkoutGateway(), keys);
+        final start = DateTime.utc(2026, 10, 20, 7);
+        await workouts.save(
+          WorkoutContent(
+            activity: Activity.running,
+            startedAt: start,
+            endedAt: start.add(const Duration(minutes: 20)),
+          ),
+          chunksOf(
+            SeriesKind.position,
+            start: start,
+            times: const [0],
+            columns: {
+              'lat': [475500000],
+              'lon': [96800000],
+            },
+          ),
+        );
+        await openRoutes(tester, workouts: workouts);
+        await tester.tap(find.text('New route'));
+        await tester.runAsync(pumpEventQueue);
+        await tester.pumpAndSettle();
+
+        expect(camera(tester).zoom, 14);
+        expect(camera(tester).center.latitude, closeTo(47.55, 1e-6));
+        expect(camera(tester).center.longitude, closeTo(9.68, 1e-6));
+      });
+
+      testWidgets('else the region, as before', (tester) async {
+        await openRoutes(tester);
+        await tester.tap(find.text('New route'));
+        await tester.pumpAndSettle();
+
+        expect(camera(tester).zoom, lessThan(10));
+      });
+    });
+
+    testWidgets("from expanded windows on, the planner's details beside its "
+        'map (D63)', (tester) async {
+      await openRoutes(tester);
+      tester.view.physicalSize = const Size(1280, 800);
+      await tester.tap(find.text('New route'));
+      await tester.pumpAndSettle();
+
+      expect(
+        tester.getTopRight(find.byType(FlutterMap)).dx,
+        lessThanOrEqualTo(tester.getTopLeft(find.text('Name')).dx),
+      );
+    });
+
     testWidgets('the activity picks the profile, which plans the way again', (
       tester,
     ) async {
@@ -3758,8 +3843,9 @@ void main() {
       );
     });
 
-    testWidgets('home and a workout’s page run on beneath the floating bar, '
+    testWidgets('home runs on beneath the floating bar, its list ending '
-        'their lists ending clear of it', (tester) async {
+        "clear of it; a workout's page covers the bar, its sheet ending clear "
+        "of the screen's foot (D63)", (tester) async {
       for (var day = 1; day <= 12; day++) {
         await saveRun(DateTime(2026, 10, day, 7, 30));
       }
@@ -3790,7 +3876,21 @@ void main() {
       await tester.pumpAndSettle();
       await tester.tap(find.text('Morning run').first);
       await tester.pumpAndSettle();
-      await endsClearOfTheBar(find.byType(Scrollable).last);
+
+      expect(bar, findsNothing);
+      final sheet = find.descendant(
+        of: find.byType(DraggableScrollableSheet),
+        matching: find.byType(Scrollable),
+      );
+      for (var i = 0; i < 3; i++) {
+        await tester.drag(sheet, const Offset(0, -5000));
+        await tester.pumpAndSettle();
+      }
+      final items = find.descendant(of: sheet, matching: find.byType(Text));
+      expect(
+        tester.getBottomLeft(items.last).dy,
+        lessThanOrEqualTo(screen - 48),
+      );
     });
 
     testWidgets('above them, this week: its time, distance and workouts, and '
@@ -3891,14 +3991,18 @@ void main() {
       expect(find.text('2.50 km'), findsOneWidget);
       expect(find.text('20 m'), findsOneWidget);
       expect(find.text('whole time'), findsOneWidget);
-      expect(
+      // What the map's source sees, one tap away (D63).
-        find.text(
+      const sees =
           "Map by OpenFreeMap: it sees your device's address and the area "
-          'shown, not your track.',
+          'shown, not your track.';
-        ),
+      expect(find.text(sees), findsNothing);
-        findsOneWidget,
+      await tester.tap(find.byTooltip("What's this?"));
-      );
+      await tester.pumpAndSettle();
+      expect(find.text('About the map'), findsOneWidget);
+      expect(find.text(sees), findsOneWidget);
       expect(find.text('What OpenFreeMap keeps'), findsOneWidget);
+      await tester.tap(find.text('OK'));
+      await tester.pumpAndSettle();
       await tester.scrollUntilVisible(find.text('km 3'), 200);
       expect(find.text('Splits'), findsOneWidget);
       expect(find.text('km 1'), findsOneWidget);
@@ -3925,6 +4029,8 @@ void main() {
 
       await tester.tap(find.text('Morning run'));
       await tester.pumpAndSettle();
+      await tester.tap(find.byTooltip("What's this?"));
+      await tester.pumpAndSettle();
 
       expect(
         find.text(
@@ -3936,6 +4042,115 @@ void main() {
       expect(find.textContaining('sees your device'), findsNothing);
     });
 
+    group("a workout's page as Strava's (D63)", () {
+      MapCamera camera(WidgetTester tester) =>
+          MapCamera.of(tester.element(find.byType(PolylineLayer)));
+
+      Future<void> openRun(WidgetTester tester) async {
+        await saveRun(DateTime(2026, 10, 27, 7, 30));
+        await startWith(tester);
+        await tester.tap(find.text('Morning run'));
+        await tester.pumpAndSettle();
+      }
+
+      testWidgets('its map to the foot of the screen, under a sheet with its '
+          'name; pulled down, the map fits the track anew, closer', (
+        tester,
+      ) async {
+        await openRun(tester);
+        expect(
+          tester.getBottomLeft(find.byType(FlutterMap)).dy,
+          tester.view.physicalSize.height,
+        );
+        final sheet = find.byType(DraggableScrollableSheet);
+        expect(
+          find.descendant(of: sheet, matching: find.text('Morning run')),
+          findsOneWidget,
+        );
+        final before = camera(tester);
+
+        await tester.drag(find.text('2.50 km'), const Offset(0, 400));
+        await tester.pumpAndSettle();
+        await tester.pump(const Duration(seconds: 1));
+        await tester.pumpAndSettle();
+
+        expect(camera(tester).zoom, greaterThan(before.zoom));
+        expect(
+          camera(tester).center.latitude,
+          greaterThan(before.center.latitude),
+          reason:
+              'the track lower on the larger map: the map looks south of it',
+        );
+      });
+
+      testWidgets("pulled up, the round back button turns into a bar's "
+          'chevron that lowers the sheet again', (tester) async {
+        await openRun(tester);
+        expect(find.byTooltip('Back'), findsOneWidget);
+        expect(find.byTooltip('Show the map'), findsNothing);
+
+        await tester.drag(find.text('2.50 km'), const Offset(0, -2000));
+        await tester.pumpAndSettle();
+        expect(find.byTooltip('Show the map'), findsOneWidget);
+        expect(find.byTooltip('Back'), findsNothing);
+
+        await tester.tap(find.byTooltip('Show the map'));
+        await tester.pumpAndSettle();
+        expect(find.byTooltip('Back'), findsOneWidget);
+        await tester.tap(find.byTooltip('Back'));
+        await tester.pumpAndSettle();
+        expect(find.byType(WorkoutScreen), findsNothing);
+      });
+
+      testWidgets('from expanded windows on, the map beside the rest', (
+        tester,
+      ) async {
+        await saveRun(DateTime(2026, 10, 27, 7, 30));
+        await startWith(tester);
+        tester.view.physicalSize = const Size(1280, 800);
+        await tester.pumpAndSettle();
+        await tester.tap(find.text('Morning run').last);
+        await tester.pumpAndSettle();
+
+        expect(find.byType(DraggableScrollableSheet), findsNothing);
+        expect(
+          tester.getTopRight(find.byType(FlutterMap)).dx,
+          lessThanOrEqualTo(tester.getTopLeft(find.text('2.50 km')).dx),
+        );
+      });
+
+      testWidgets("the map's credit opens on the theme's surface, in its "
+          'colours', (tester) async {
+        await openRun(tester);
+        final credit = tester.widget<RichAttributionWidget>(
+          find.byType(RichAttributionWidget),
+        );
+        final scheme = Theme.of(
+          tester.element(find.byType(RichAttributionWidget)),
+        ).colorScheme;
+        expect(credit.popupBackgroundColor, scheme.surfaceContainerHigh);
+
+        await tester.tap(find.byTooltip('Map credits'));
+        await tester.pumpAndSettle();
+        final text = find.textContaining('OpenFreeMap © OpenMapTiles');
+        expect(text, findsOneWidget);
+        expect(
+          tester
+              .widget<Text>(
+                find
+                    .descendant(
+                      of: find.byType(TextSourceAttribution),
+                      matching: find.byType(Text),
+                    )
+                    .first,
+              )
+              .style
+              ?.color,
+          scheme.onSurface,
+        );
+      });
+    });
+
     testWidgets("a workout with a strap shows the heart's average and highest "
         'rate, by split too, and its chart', (tester) async {
       await saveRun(DateTime(2026, 10, 27, 7, 30), strap: true);