diff --git a/Apps/Maps/CHANGELOG.md b/Apps/Maps/CHANGELOG.md
index 0abef58..11416a8 100644
--- a/Apps/Maps/CHANGELOG.md
+++ b/Apps/Maps/CHANGELOG.md
@@ -1,5 +1,99 @@
 # Changelog
 
+## 0.8.1
+
+**Menu**
+- The main menu is a grid of nine tiles with icons: Search, Download, Maps, Waypoints, Track, GPX, Location,
+  Settings, About. W A S D or the arrows move in both directions, Enter opens, Esc closes; the trackball moves tile by
+  tile or points; tap a tile. The menu opens on the tile used last.
+- A strip above the tiles shows what is running, only while it runs: the download with its progress, and Show route
+  or Stop and Clear route while there is a route.
+- Location switches on and off in place and shows its state on the tile. Exit is a small button at the top right.
+- Waypoints always opens the list; its first row is "Add waypoint here" (P and a long press on the map still add one).
+
+**Following a GPX track**
+- Menu, GPX, a file, "Follow this track": the first track or route of the file becomes the route (its card shows
+  the length and walking time; Start follows it with the bar, the remaining distance and the arrival). No turns are
+  announced, and away from the track the bar says "Off the track" with the distance instead of searching another
+  way. Tracks of any length (long ones are thinned to 6,000 points). Choosing a file now asks: show or hide it on
+  the map, or follow it.
+
+**Off the route**
+- A new route comes much faster on a long route: the app looks for the way back to the route a little ahead and
+  keeps the rest of it, instead of searching all the way to the destination again (which took seconds, by which
+  time a bike or a bus was somewhere else, so the new route was left at once and the bar never stopped
+  "recalculating").
+- A new route is asked for at once every time the route is left, from the position itself (the 10 seconds between
+  two new routes are gone). Only after a search that found no way does the next one wait 5 seconds; the bar then
+  shows how far the route is and that there is no new route yet.
+- Long car routes first look along the larger roads between their two ends, as a driver would: more routes
+  across a city are found (49 of 50 test pairs on the T-Deck, 48 before) and they come a little faster.
+- While navigating, what the app saw (positions, distance from the route, new routes) is written to `navlog.txt`
+  in the app's folder, to find out afterwards what happened on a trip.
+
+**Faster**
+- Names and icons appear sooner after the map stops moving: placing them takes a quarter to almost half less
+  time on the T-Deck.
+
+**Long routes**
+- Routes between towns and across a country: near the start and the destination the app uses the streets of the
+  detailed map, between them the main roads of the zoomed-out map (zoom 10). The detailed map is only needed around
+  both ends; for the way between, download the wider area once while zoomed out. On the T-Deck a 27 km route
+  between two towns with no detailed map between them is found in 2 to 8 seconds.
+- A new route in the middle of such a drive starts on the main road you are on, also where no detailed map is
+  on the card.
+- On the main roads the line is the zoomed-out map's, a little coarser than the road on screen; the app allows
+  for that before it says you left the route.
+- A map that was just downloaded can be routed on at once: the search prepares the tiles it needs itself
+  (before, the route was "not found" until the app had prepared them in idle time).
+
+**Search**
+- Exact names are ordered by what they are before how near they are: a town or village first, then stations,
+  airports, hospitals, malls, museums and the like, then other places, and bus stops, information boards and such
+  last (a bus stop named like the station no longer comes before the station).
+- Streets that only have an international name in the map data are found (Athens: 893 of 9,542 street lines).
+  The search indexes on the card are made again in idle time for this.
+
+**Controls and screens**
+- A search button among the map's controls, under the menu button (key /).
+- Settings: one line under the list says what the highlighted setting does.
+- With a keyboard, the waypoint sheet, the route card and the download card show their keys in one small line.
+- On boards without a keyboard, list rows and buttons are at least 36 px high.
+- The same margins, corner radii and dimming on every sheet, card and dialog; Backspace in the search field always
+  deletes a letter and only closes when the field is empty.
+
+**Labels and POIs**
+- Labels no longer jump when the map is moved: their places are fixed to the map, a label at the screen's edge is cut
+  instead of dropped, the same view always gives the same labels, and small labels (streets, POIs, house numbers) that
+  are on screen stay while the map moves or zooms.
+- More POIs: each takes only the room of its icon (the box around it was more than twice as wide as the icon), and
+  all icons are placed before any name. A POI's name shows from zoom 17 where there is room next to its icon; select
+  the icon to read it otherwise. Bratislava centre at zoom 17: 61 POIs on screen (11 before), all of them at zoom 19.
+- Zoomed out, cities show by importance: the capitals and largest cities first, more with every zoom level, the same
+  rule everywhere (Krakow no longer shows where Wien and Budapest do not). Country names are smaller from zoom 5 so
+  capitals fit between them; a city or country name moves a little above, below or beside its point when its place
+  is taken; regions (Burgenland) come after cities.
+
+**Fixes**
+- Recorded tracks: a write that the card cut short no longer leaves a broken point followed by the same points
+  again; closing an unfinished track after a crash never leaves the card without the track.
+- Region information, settings, the last view and the waypoints are replaced safely: a failed write keeps the old
+  file, and a power cut between the two steps is repaired at the next start.
+- Deleting a region also removes its search index (the folder used to stay behind).
+- Damaged map files end with an error instead of hanging or overrunning memory: tiles whose compressed data never
+  ends, wrong sizes in prepared tiles and label files, broken geometry commands, label points far outside the tile.
+- The search index build and the preparation of tiles in the background no longer run at the same time (the two
+  together left 67 KB less memory free).
+- Navigation: a weak GPS signal far from the route ends the "off route" state instead of asking for a new route
+  again and again; running out of memory during a route search says so instead of "no route".
+- Downloaded maps: an action chosen while the list changes (a download finishing) acts on the region that was chosen.
+- Recorded tracks are listed newest first; a failed settings write puts the setting back; "No tracks yet" and a
+  catalog that cannot be read no longer change where About returns to.
+- GPX: names keep whole letters when cut, control characters are left out, empty names are not written with every
+  track point, "inf" and "nan" are not read as elevations.
+- Search: a house number of 65535 no longer matches addresses without a number; a very long word is one word.
+- The Enter walk over POIs takes the nearest ones first when more than 16 are on screen.
+
 ## 0.5.0
 
 Offline search of places, streets, addresses and kinds of places in the downloaded maps.
diff --git a/Apps/Maps/README.md b/Apps/Maps/README.md
index 64bf64e..f471776 100644
--- a/Apps/Maps/README.md
+++ b/Apps/Maps/README.md
@@ -15,7 +15,7 @@ for downloading maps. Tested on Tactility 0.8.0-dev (main, November 2026) on a L
 1. Install "Maps" from Tactility's App Hub. Or copy the `.app` file to the SD card, open it in the Files app and
    confirm "Install".
 2. Start "Maps" from the app list. The first time it opens at ESA ESTEC in Noordwijk with no map data yet: move
-   to your area, open the menu (M or ☰) and choose Download map.
+   to your area, open the menu (M or ☰) and choose Download.
 
 ## How it works
 
@@ -51,7 +51,7 @@ circle), the scale bar, and the © mark.
 | Add a waypoint | P | — | Hold ⌖ (your position) or hold the map (that point) |
 | A place or house number | Show the controls, then Enter (nearest the crosshair; Enter again: next) | Click it | Tap it |
 | Menu | M | Long click | ☰ button |
-| Download an area | Shift + D | — | Menu → Download map |
+| Download an area | Shift + D | — | Menu → Download |
 | Leave the download frame | Esc | — | The round < in its top left corner |
 | Type a name (waypoint, rename) | Keyboard | — | On-screen keyboard |
 | Credits | — | Click © | Tap ©, tap again for About and licences |
@@ -176,9 +176,14 @@ takes about 5 minutes on a T-Deck; it is made again when the region's tiles are
 z14 tiles get one index per block of 15 x 15 tiles. Until a region's index is ready, search doesn't find anything in
 it. The PC tool `host/search_build --tiles` makes the same file.
 
-**Menu:** Download map, Downloaded maps, Waypoints, Add waypoint, Record track, GPX files, Location, Settings, About and
-licences, Exit. W/S, trackball or finger to move; Enter, click or tap to choose; Esc, Backspace or tap
-outside to close.
+**Menu (0.6.0):** a grid of nine tiles: Search, Download (choose an area on the map or a region from the list), Maps (the
+downloaded maps), Waypoints (the list; its first row adds one at the map's centre), Track (record, pause, stop,
+recorded tracks), GPX (files to show), Location (switches on and off in place; the tile says On or Off), Settings,
+About. W A S D, the arrows or the trackball move from tile to tile, Enter or a click opens, a tap opens directly;
+Esc, Backspace, M, a swipe to the right or the arrow at the top left close it. The menu opens on the tile you used
+last. While a download runs or a route exists, a strip above the tiles shows it: the download with its progress
+(opens the download card), Show route or Stop, and Clear route. Exit is the small button at the top right.
+With the controls shown there is also a search button under the menu button (key /).
 
 **Lists and actions.** Enter or a tap on a row opens its actions; lists have a back arrow and a check
 mark in their header; swipe right or the back arrow goes back, and dragging a list scrolls it. Lists open
@@ -227,7 +232,7 @@ not updated.
 Tactility's location service on or off, with a message. If it's off, the ⌖ button is crossed out and
 pressing it says how to enable it in Tactility's settings.
 
-**Waypoints:** P, or holding ⌖, saves a waypoint at your position; Menu → Add waypoint saves one at the
+**Waypoints:** P, or holding ⌖, saves a waypoint at your position; Menu → Waypoints → Add waypoint here saves one at the
 map centre; on touch screens holding the map saves one where you hold. A sheet asks for the name of a
 new waypoint; typing replaces the suggested name. Waypoints are named WP 001, WP 002, …; they show as
 pins at every zoom level, all the same size. Tap a pin for its card: name, coordinates and distance and
@@ -235,7 +240,7 @@ direction from you. Esc closes the card. Menu → Waypoints lists them by distan
 there, R renames (keyboard), Del or hold deletes after asking. They are kept in `waypoints.gpx` (GPX 1.1)
 in the app's folder on the card.
 
-**Track recording:** Menu → Record track → Start recording. A red ● with the time shows top right (with
+**Track recording:** Menu → Track → Start recording. A red ● with the time shows top right (with
 the controls shown also the distance). The same menu entry pauses, resumes and stops. Points are taken
 from the position when you moved more than 5 m (or more than the GPS accuracy), or every 30 s while
 moving; approximate positions (from the network) are skipped. The track is drawn on the map as a red
diff --git a/Apps/Maps/main/Source/app/BinFontText.cpp b/Apps/Maps/main/Source/app/BinFontText.cpp
index 9e7a0db..2ec1710 100644
--- a/Apps/Maps/main/Source/app/BinFontText.cpp
+++ b/Apps/Maps/main/Source/app/BinFontText.cpp
@@ -123,6 +123,7 @@ void BinFontText::close() {
     }
     font = nullptr;
     owned = false;
+    dropGlyphs();
 }
 
 namespace {
@@ -220,22 +221,85 @@ void BinFontText::drawText(Canvas& canvas, int x, int y, const char* text, uint1
     binfont_draw_text_rgb565(target, x, y + ascentPixels, font, withFallback(text), color, PIXEL_BUFFER_CONVERSION_AVERAGE);
 }
 
+void BinFontText::dropGlyphs() {
+    if (glyphs != nullptr) {
+        largeFree(glyphs);
+        largeFree(glyphMasks);
+    }
+    glyphs = nullptr;
+    glyphMasks = nullptr;
+    glyphMasksUsed = 0;
+}
+
 bool BinFontText::glyph(uint32_t codepoint, LabelGlyph& out, bool withMask) {
-    BinFontGlyph found;
-    if (font == nullptr || !binfont_get_glyph(font, codepoint, &found)) {
+    if (font == nullptr) {
         return false;
     }
-    out.id = found.glyph_id;
-    out.advanceX16 = static_cast<int>(found.advance_x16);
-    out.left = found.x;
-    // binfont gives the box's bottom above the baseline, labels want its top below it
-    out.top = -(found.y + found.height);
-    out.width = found.width;
-    out.height = found.height;
+    if (glyphs == nullptr) {
+        // Without memory for the cache every glyph is looked up as before
+        glyphs = static_cast<CachedGlyph*>(largeAlloc(sizeof(CachedGlyph) * GLYPH_SLOTS));
+        glyphMasks = glyphs != nullptr ? static_cast<uint8_t*>(largeAlloc(GLYPH_MASK_BYTES)) : nullptr;
+        if (glyphMasks == nullptr) {
+            largeFree(glyphs);
+            glyphs = nullptr;
+        } else {
+            memset(glyphs, 0, sizeof(CachedGlyph) * GLYPH_SLOTS);
+            glyphMasksUsed = 0;
+        }
+    }
+    CachedGlyph* cached = glyphs != nullptr ? &glyphs[(codepoint * 2654435761u) >> 24] : nullptr;
+    BinFontGlyph found {};
+    bool looked = false;
+    if (cached == nullptr || !cached->used || cached->codepoint != codepoint) {
+        if (!binfont_get_glyph(font, codepoint, &found)) {
+            return false;
+        }
+        looked = true;
+        out.id = found.glyph_id;
+        out.advanceX16 = static_cast<int>(found.advance_x16);
+        out.left = found.x;
+        // binfont gives the box's bottom above the baseline, labels want its top below it
+        out.top = -(found.y + found.height);
+        out.width = found.width;
+        out.height = found.height;
+        if (cached != nullptr) {
+            *cached = { codepoint, static_cast<uint32_t>(out.id), static_cast<int32_t>(out.advanceX16), NO_MASK, static_cast<int16_t>(out.left),
+                static_cast<int16_t>(out.top), static_cast<uint16_t>(out.width), static_cast<uint16_t>(out.height), true };
+        }
+    } else {
+        out.id = cached->id;
+        out.advanceX16 = cached->advanceX16;
+        out.left = cached->left;
+        out.top = cached->top;
+        out.width = cached->width;
+        out.height = cached->height;
+    }
     out.alpha = nullptr;
-    if (withMask && found.width > 0 && found.height > 0 && found.width * found.height <= MASK_BYTES &&
-        binfont_get_glyph_bitmap(font, &found, mask, found.width) == ERROR_NONE) {
-        out.alpha = mask;
+    const uint32_t size = static_cast<uint32_t>(out.width) * static_cast<uint32_t>(out.height);
+    if (!withMask || size == 0 || size > MASK_BYTES) {
+        return true;
+    }
+    if (cached != nullptr && cached->maskOffset != NO_MASK) {
+        out.alpha = glyphMasks + cached->maskOffset;
+        return true;
+    }
+    if (!looked && !binfont_get_glyph(font, codepoint, &found)) {
+        return true;
+    }
+    if (cached != nullptr && glyphMasksUsed + size > GLYPH_MASK_BYTES) {
+        // Full (a view with several scripts): started again, this glyph is its first
+        const CachedGlyph keep = *cached;
+        memset(glyphs, 0, sizeof(CachedGlyph) * GLYPH_SLOTS);
+        glyphMasksUsed = 0;
+        *cached = keep;
+    }
+    uint8_t* into = cached != nullptr ? glyphMasks + glyphMasksUsed : mask;
+    if (binfont_get_glyph_bitmap(font, &found, into, found.width) == ERROR_NONE) {
+        out.alpha = into;
+        if (cached != nullptr) {
+            cached->maskOffset = glyphMasksUsed;
+            glyphMasksUsed += size;
+        }
     }
     return true;
 }
diff --git a/Apps/Maps/main/Source/app/BinFontText.h b/Apps/Maps/main/Source/app/BinFontText.h
index 290b483..e850fa4 100644
--- a/Apps/Maps/main/Source/app/BinFontText.h
+++ b/Apps/Maps/main/Source/app/BinFontText.h
@@ -56,6 +56,30 @@ class BinFontText final : public Font, public LabelFont {
     /** The mask of the last glyph asked for with withMask; labels use fonts of at most about 30 px. */
     static constexpr int MASK_BYTES = 48 * 48;
     uint8_t mask[MASK_BYTES] {};
+    /**
+     * The glyphs asked for before, with their masks: looking a glyph up and unpacking its bitmap in the binfont-module
+     * took about 2 ms per label, most of the time of placing the labels of a view (15 Nov). Direct mapped by
+     * codepoint; the masks in one block of PSRAM that is started again when it is full.
+     */
+    struct CachedGlyph {
+        uint32_t codepoint;
+        uint32_t id;
+        int32_t advanceX16;
+        /** Into glyphMasks; NO_MASK when the mask was not asked for yet (or is too large). */
+        uint32_t maskOffset;
+        int16_t left;
+        int16_t top;
+        uint16_t width;
+        uint16_t height;
+        bool used;
+    };
+    static constexpr int GLYPH_SLOTS = 256;
+    static constexpr uint32_t GLYPH_MASK_BYTES = 24 * 1024;
+    static constexpr uint32_t NO_MASK = UINT32_MAX;
+    void dropGlyphs();
+    CachedGlyph* glyphs = nullptr;
+    uint8_t* glyphMasks = nullptr;
+    uint32_t glyphMasksUsed = 0;
     /** The canvas the text was last drawn on, wrapped once as a PixelBuffer. */
     PixelBuffer* target = nullptr;
     uint16_t* targetPixels = nullptr;
diff --git a/Apps/Maps/main/Source/app/BrowsedCounter.cpp b/Apps/Maps/main/Source/app/BrowsedCounter.cpp
index 4366318..250ba45 100644
--- a/Apps/Maps/main/Source/app/BrowsedCounter.cpp
+++ b/Apps/Maps/main/Source/app/BrowsedCounter.cpp
@@ -41,6 +41,7 @@ bool countJob(IoTask& io, void* context) {
     auto* job = static_cast<CountJob*>(context);
     job->count = 0;
     job->complete = false;
+    bool truncated = false;
     for (int z = job->plan.minZoom; z <= job->plan.maxZoom; z++) {
         const TileRange range = tileRange(job->plan.box, z);
         char folder[220];
@@ -64,7 +65,8 @@ bool countJob(IoTask& io, void* context) {
             }
         }
         closedir(columns);
-        (void)more;
+        // Columns beyond the list are not counted, so the result must not pass as complete
+        truncated = truncated || more;
         for (int i = 0; i < insideCount; i++) {
             // Tiles on screen come first: give the card back and say the count is not complete
             if (io.shouldYield()) {
@@ -85,6 +87,10 @@ bool countJob(IoTask& io, void* context) {
             closedir(files);
         }
     }
+    // Still complete: an incomplete count is counted again without end. The number is then too low; say so in the log.
+    if (truncated) {
+        logError("Browsed tiles: more than 96 columns in a zoom level, the count is too low");
+    }
     job->complete = true;
     return true;
 }
diff --git a/Apps/Maps/main/Source/app/Debug.cpp b/Apps/Maps/main/Source/app/Debug.cpp
index f7c5ab2..43831cb 100644
--- a/Apps/Maps/main/Source/app/Debug.cpp
+++ b/Apps/Maps/main/Source/app/Debug.cpp
@@ -145,6 +145,30 @@ DebugScript::Step DebugScript::next(uint32_t now) {
             step.action = Action::TouchOnly;
             return step;
         }
+        if (strcmp(command, "pointer") == 0) {
+            // "pointer <x> <y>": the trackball pointer is shown there; "key c" then clicks at it
+            step.action = Action::Pointer;
+            step.values[0] = step.values[1] = 0.0f;
+            sscanf(argument, "%f %f", &step.values[0], &step.values[1]);
+            return step;
+        }
+        if (strcmp(command, "followgpx") == 0) {
+            // "followgpx <file>": follows the track of a GPX file in the app's folder, as Menu, GPX, Follow this track
+            step.action = Action::FollowGpx;
+            snprintf(step.name, sizeof(step.name), "%s", argument);
+            return step;
+        }
+        if (strcmp(command, "restart") == 0) {
+            // "restart": the board restarts (a failed app load leaves Tactility with less memory until it does)
+            step.action = Action::Restart;
+            return step;
+        }
+        if (strcmp(command, "memory") == 0) {
+            // "memory <label>": logs the free memory and the stack left of every task of the app
+            step.action = Action::Memory;
+            snprintf(step.name, sizeof(step.name), "%s", argument);
+            return step;
+        }
         if (strcmp(command, "squeeze") == 0) {
             step.action = Action::Squeeze;
             step.zoom = atoi(argument);
@@ -155,7 +179,7 @@ DebugScript::Step DebugScript::next(uint32_t now) {
             return strcmp(text, "bike") == 0 ? 1 : (strcmp(text, "car") == 0 ? 2 : (strcmp(text, "all") == 0 ? 3 : 0));
         };
         char word[16] = "";
-        if (strcmp(command, "routebench") == 0 && sscanf(argument, "%31s %15s", step.name, word) >= 1) {
+        if (strcmp(command, "routebench") == 0 && sscanf(argument, "%47s %15s", step.name, word) >= 1) {
             step.action = Action::RouteBench;
             step.zoom = profileOf(word);
             return step;
@@ -169,7 +193,7 @@ DebugScript::Step DebugScript::next(uint32_t now) {
             step.action = Action::WaitRoute;
             return step;
         }
-        if (strcmp(command, "replay") == 0 && sscanf(argument, "%31s %f %f %f", step.name, &step.values[0], &step.values[1], &step.values[2]) >= 1) {
+        if (strcmp(command, "replay") == 0 && sscanf(argument, "%47s %f %f %f", step.name, &step.values[0], &step.values[1], &step.values[2]) >= 1) {
             // replay <file> [accuracy m] [noise m] [seed]
             step.action = Action::Replay;
             return step;
@@ -178,7 +202,7 @@ DebugScript::Step DebugScript::next(uint32_t now) {
             step.action = Action::SearchIndex;
             step.zoom = strncmp(argument, "force", 5) == 0 ? 1 : 0;
             // "searchindex force <region>": that region only
-            if (step.zoom != 0 && sscanf(argument, "force %31s", step.name) != 1) {
+            if (step.zoom != 0 && sscanf(argument, "force %47s", step.name) != 1) {
                 step.name[0] = '\0';
             }
             return step;
@@ -187,11 +211,11 @@ DebugScript::Step DebugScript::next(uint32_t now) {
             step.action = Action::WaitSearchIndex;
             return step;
         }
-        if (strcmp(command, "filecheck") == 0 && sscanf(argument, "%31s", step.name) == 1) {
+        if (strcmp(command, "filecheck") == 0 && sscanf(argument, "%47s", step.name) == 1) {
             step.action = Action::FileCheck;
             return step;
         }
-        if (strcmp(command, "offroute") == 0 && sscanf(argument, "%31s %f", step.name, &step.values[0]) == 2) {
+        if (strcmp(command, "offroute") == 0 && sscanf(argument, "%47s %f", step.name, &step.values[0]) == 2) {
             step.action = Action::OffRoute;
             return step;
         }
diff --git a/Apps/Maps/main/Source/app/Debug.h b/Apps/Maps/main/Source/app/Debug.h
index 159edfb..4bbe14a 100644
--- a/Apps/Maps/main/Source/app/Debug.h
+++ b/Apps/Maps/main/Source/app/Debug.h
@@ -48,7 +48,15 @@ class DebugScript {
         OffRoute,
         SearchIndex,
         WaitSearchIndex,
-        FileCheck
+        FileCheck,
+        /** "pointer <x> <y>": shows the trackball pointer there, as if rolled to it ("key c" clicks). */
+        Pointer,
+        /** "memory <label>": logs free memory and the stack left of every task of the app. */
+        Memory,
+        /** "restart": restarts the board. */
+        Restart,
+        /** "followgpx <file>": follows the track of a GPX file in the app's folder. */
+        FollowGpx
     };
 
     enum class TouchKind : uint8_t { Tap, Hold, Drag, Pinch, Twist };
@@ -56,7 +64,7 @@ class DebugScript {
     struct Step {
         Action action;
         uint32_t key;
-        char name[32];
+        char name[48];
         double lat;
         double lon;
         int zoom;
diff --git a/Apps/Maps/main/Source/app/Downloader.cpp b/Apps/Maps/main/Source/app/Downloader.cpp
index 15fb0a1..5e09dc0 100644
--- a/Apps/Maps/main/Source/app/Downloader.cpp
+++ b/Apps/Maps/main/Source/app/Downloader.cpp
@@ -157,7 +157,8 @@ void* Downloader::createClient(Connection* connection) {
 void Downloader::beginHandshake(Connection& connection) {
     // One handshake at a time: each is 2-3.6 s of CPU on the network core, two at once kept its idle task from the
     // task watchdog
-    xSemaphoreTake(handshakeLock, pdMS_TO_TICKS(HTTP_TIMEOUT_MS));
+    // Not taken in time (another handshake hangs): go on without it, and do not give it back
+    connection.handshakeLocked = xSemaphoreTake(handshakeLock, pdMS_TO_TICKS(HTTP_TIMEOUT_MS)) == pdTRUE;
     connection.handshaking = true;
     handshakes++;
 }
@@ -166,7 +167,10 @@ void Downloader::endHandshake(Connection& connection) {
     if (connection.handshaking) {
         connection.handshaking = false;
         handshakes--;
-        xSemaphoreGive(handshakeLock);
+        if (connection.handshakeLocked) {
+            connection.handshakeLocked = false;
+            xSemaphoreGive(handshakeLock);
+        }
     }
 }
 
@@ -435,6 +439,41 @@ bool removeJob(IoTask& io, void* context) {
     return (job->folder ? rmdir(job->path) : remove(job->path)) == 0;
 }
 
+constexpr int BATCH_SIZE = 16;
+
+/** Removes the files of a folder (not its subfolders), a few at a time so no name list can overflow. */
+bool clearFolderJob(IoTask& io, void* context) {
+    (void)io;
+    const char* folder = static_cast<const RemoveJob*>(context)->path;
+    struct Batch {
+        char names[BATCH_SIZE][24];
+        int count;
+    };
+    Batch batch {};
+    for (;;) {
+        batch.count = 0;
+        listDirectory(folder, [](const char* name, bool isDirectory, void* data) {
+            auto* batch = static_cast<Batch*>(data);
+            if (!isDirectory && strlen(name) < sizeof(batch->names[0])) {
+                snprintf(batch->names[batch->count++], sizeof(batch->names[0]), "%s", name);
+            }
+            return batch->count < BATCH_SIZE;
+        }, &batch);
+        int removed = 0;
+        for (int i = 0; i < batch.count; i++) {
+            char path[PATH_MAX_LENGTH];
+            snprintf(path, sizeof(path), "%s/%s", folder, batch.names[i]);
+            if (remove(path) == 0) {
+                removed++;
+            }
+        }
+        // A full batch may have more behind it; stop when nothing could be removed
+        if (batch.count < BATCH_SIZE || removed == 0) {
+            return true;
+        }
+    }
+}
+
 } // namespace
 
 bool Downloader::start(const char* root, TileStore* tileStore, IoTask* ioTask) {
@@ -559,7 +598,15 @@ bool Downloader::loadOutlineTiles(const RegionMeta& region) {
     CatalogJob job { catalogPath, &file };
     RegionCatalog catalog;
     if (catalogPath[0] == '\0' || !io->run(IoPriority::Background, readCatalogJob, &job) || !catalog.open(file.bytes(), file.size())) {
-        logError("Region catalog %s not readable", catalogPath);
+        // Told apart for the log: the file is there but did not fit into memory (it is read whole, 357 KB), or it is not
+        uint32_t bytes = 0;
+        outlineNoMemory = fileSize(catalogPath, bytes);
+        if (outlineNoMemory) {
+            logError("Region catalog %s: no memory for its %u bytes (largest free block %u)", catalogPath, static_cast<unsigned>(bytes),
+                static_cast<unsigned>(heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM)));
+        } else {
+            logError("Region catalog %s not readable", catalogPath);
+        }
         return false;
     }
     int index = -1;
@@ -1087,7 +1134,7 @@ void Downloader::runDownload() {
         return;
     }
     if (!loadOutlineTiles(meta)) {
-        setStatus(State::Failed, "Region outline is missing");
+        setStatus(State::Failed, outlineNoMemory ? "Not enough memory for the region list" : "Region outline is missing");
         return;
     }
     if (!wifiConnected()) {
@@ -1671,7 +1718,7 @@ void Downloader::runUpdate(bool manual) {
     if (!loadOutlineTiles(target)) {
         largeFree(progress.bits);
         giveClient(connection);
-        setStatus(State::Failed, "Region outline is missing");
+        setStatus(State::Failed, outlineNoMemory ? "Not enough memory for the region list" : "Region outline is missing");
         return;
     }
     bool failedTile = false;
@@ -1821,6 +1868,22 @@ void Downloader::runDelete() {
     RemoveJob metaFile {};
     snprintf(metaFile.path, sizeof(metaFile.path), "%s/maps/%s/meta.json", rootPath, target.name);
     io->run(IoPriority::Background, removeJob, &metaFile);
+    // What the search index left in the region: the stamp, the index, the update list, the block and scratch folders.
+    // Otherwise the folder is not empty and stays behind.
+    static const char* const LEFTOVER_FILES[] = { "search.inf", "search.idx", "search.tmp", "stamp.tmp", "update.bin" };
+    for (const char* leftover : LEFTOVER_FILES) {
+        RemoveJob file {};
+        snprintf(file.path, sizeof(file.path), "%s/maps/%s/%s", rootPath, target.name, leftover);
+        io->run(IoPriority::Background, removeJob, &file);
+    }
+    static const char* const LEFTOVER_FOLDERS[] = { "search", "srch" };
+    for (const char* leftover : LEFTOVER_FOLDERS) {
+        RemoveJob inside {};
+        snprintf(inside.path, sizeof(inside.path), "%s/maps/%s/%s", rootPath, target.name, leftover);
+        io->run(IoPriority::Background, clearFolderJob, &inside);
+        inside.folder = true;
+        io->run(IoPriority::Background, removeJob, &inside);
+    }
     RemoveJob folder {};
     snprintf(folder.path, sizeof(folder.path), "%s/maps/%s", rootPath, target.name);
     folder.folder = true;
diff --git a/Apps/Maps/main/Source/app/Downloader.h b/Apps/Maps/main/Source/app/Downloader.h
index cb4867e..87f3eac 100644
--- a/Apps/Maps/main/Source/app/Downloader.h
+++ b/Apps/Maps/main/Source/app/Downloader.h
@@ -158,6 +158,8 @@ class Downloader {
         bool connected = false;
         /** Whether this connection holds the handshake lock. */
         bool handshaking = false;
+        /** This connection holds the handshake lock (taking it can time out). */
+        bool handshakeLocked = false;
         /** Tiles moved from the browsed region instead of downloaded in this run, and their bytes. */
         int movedTiles = 0;
         uint64_t moved = 0;
@@ -236,6 +238,8 @@ class Downloader {
     SemaphoreHandle_t wake = nullptr;
     SemaphoreHandle_t stopped = nullptr;
     TaskHandle_t controlTask = nullptr;
+    /** The last loadOutlineTiles() failed for memory, not for a missing catalog (for the status text). */
+    bool outlineNoMemory = false;
     std::atomic<bool> stopRequested = false;
     std::atomic<bool> cancelRequested = false;
     std::atomic<bool> busy = false;
diff --git a/Apps/Maps/main/Source/app/Input.cpp b/Apps/Maps/main/Source/app/Input.cpp
index 7bb7c85..03aa4ac 100644
--- a/Apps/Maps/main/Source/app/Input.cpp
+++ b/Apps/Maps/main/Source/app/Input.cpp
@@ -6,6 +6,7 @@
 #include <tactility/drivers/keyboard.h>
 #include <tactility/drivers/mouse.h>
 #include <tactility/drivers/touch.h>
+#include <tactility/drivers/trackball.h>
 #include <lvgl/devices/keyboard.h>
 
 namespace maps {
@@ -94,7 +95,10 @@ void Input::rescan() {
     // (button-control) say they are not since the software keyboard fix, so they show no key hints
     const bool typingBefore = typingKeyboard;
     typingKeyboard = device_has_active_by_type(&KEYBOARD_TYPE) && lvgl_hardware_keyboard_is_available();
-    if (dropped > 0 || keyboardCount != keyboardsBefore || mouseCount != miceBefore || typingKeyboard != typingBefore) {
+    const bool trackballBefore = trackball;
+    trackball = device_has_active_by_type(&TRACKBALL_TYPE);
+    if (dropped > 0 || keyboardCount != keyboardsBefore || mouseCount != miceBefore || typingKeyboard != typingBefore ||
+        trackball != trackballBefore) {
         devicesChanged = true;
         logInfo("Input: %d keyboards, %d mice, %s", keyboardCount, mouseCount, typingKeyboard ? "typing keyboard" : "no typing keyboard");
     }
diff --git a/Apps/Maps/main/Source/app/Input.h b/Apps/Maps/main/Source/app/Input.h
index e2a6c96..91bad54 100644
--- a/Apps/Maps/main/Source/app/Input.h
+++ b/Apps/Maps/main/Source/app/Input.h
@@ -47,6 +47,8 @@ class Input {
      * present counts, as for Tactility's software keyboard.
      */
     bool hasKeyboard() const { return typingKeyboard && !touchOnly; }
+    /** A trackball (in either mode): only then do hints say "Roll". */
+    bool hasTrackball() const { return trackball && !touchOnly; }
     bool hasPointer() const { return mouseCount > 0 && !touchOnly; }
     /** Debug scripts ("touchonly"): act as a board with only a touch screen; keyboards and pointers are ignored. */
     void setTouchOnly(bool value) { touchOnly = value; }
@@ -62,6 +64,7 @@ class Input {
     Device* keyboards[MAX_DEVICES] {};
     bool touchOnly = false;
     bool typingKeyboard = false;
+    bool trackball = false;
     int keyboardCount = 0;
     Device* mice[MAX_DEVICES] {};
     int mouseCount = 0;
diff --git a/Apps/Maps/main/Source/app/IoTask.cpp b/Apps/Maps/main/Source/app/IoTask.cpp
index cc9a050..1020488 100644
--- a/Apps/Maps/main/Source/app/IoTask.cpp
+++ b/Apps/Maps/main/Source/app/IoTask.cpp
@@ -74,8 +74,14 @@ bool IoTask::run(IoPriority priority, IoJob job, void* context) {
     }
     Request request { job, context, done, false, nowMs(), prefetchGeneration.load() };
     xSemaphoreTake(mutex, portMAX_DELAY);
-    const bool queued = queue.push(&request, priority);
+    // Checked under the mutex: the task's last drain clears it there, so no request is queued after it
+    const bool accepted = runningTask;
+    const bool queued = accepted && queue.push(&request, priority);
     xSemaphoreGive(mutex);
+    if (!accepted) {
+        vSemaphoreDelete(done);
+        return false;
+    }
     if (!queued) {
         vSemaphoreDelete(done);
         logError("I/O queue full");
@@ -148,6 +154,19 @@ void IoTask::loop() {
             xSemaphoreGive(request->done);
         }
         if (stopRequested) {
+            // The last drain: a request queued since the loop above fails here instead of waiting for ever
+            xSemaphoreTake(mutex, portMAX_DELAY);
+            runningTask = false;
+            for (;;) {
+                Request* late = nullptr;
+                queue.pop(late, nullptr);
+                if (late == nullptr) {
+                    break;
+                }
+                late->result = false;
+                xSemaphoreGive(late->done);
+            }
+            xSemaphoreGive(mutex);
             break;
         }
     }
diff --git a/Apps/Maps/main/Source/app/MapCamera.cpp b/Apps/Maps/main/Source/app/MapCamera.cpp
new file mode 100644
index 0000000..9b250f4
--- /dev/null
+++ b/Apps/Maps/main/Source/app/MapCamera.cpp
@@ -0,0 +1,290 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "MapView.h"
+#include "MapViewInternal.h"
+
+#include "../platform/Platform.h"
+#include "../render/Compose.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace maps {
+
+void MapView::centerOn(double lat, double lon, int newZoom) {
+    zoom = newZoom;
+    centerX = lonToWorldX(lon, zoom);
+    centerY = latToWorldY(lat, zoom);
+    dirty = true;
+    updateWanted();
+}
+
+void MapView::centerOnPosition() {
+    const PositionFix& fix = position.fix();
+    zoom = std::clamp(zoom, 0, MAX_VIEW_ZOOM);
+    centerX = lonToWorldX(fix.longitude, zoom);
+    centerY = latToWorldY(fix.latitude, zoom);
+    if (navigating) {
+        // The position at NAVIGATION_POSITION_Y of the height: the screen centre is that far ahead of it, in the
+        // direction that is up on the (turned) screen
+        double aheadX;
+        double aheadY;
+        screenToWorldOffset(0.0, height / 2.0 - height * NAVIGATION_POSITION_Y, aheadX, aheadY);
+        const double worldSize = std::ldexp(static_cast<double>(TILE_SIZE), zoom);
+        centerX = std::fmod(centerX + aheadX + worldSize, worldSize);
+        centerY = std::fmin(std::fmax(centerY + aheadY, 0.0), worldSize);
+    }
+    dirty = true;
+    updateWanted();
+}
+
+void MapView::setZoom(int newZoom, int anchorX, int anchorY) {
+    if (newZoom < 0 || newZoom > MAX_VIEW_ZOOM || newZoom == zoom) {
+        return;
+    }
+    // The world point under the anchor stays where it is on the screen
+    double offsetX;
+    double offsetY;
+    screenToWorldOffset(anchorX - width / 2.0, anchorY - height / 2.0, offsetX, offsetY);
+    const double scale = std::ldexp(1.0, newZoom - zoom);
+    centerX = (centerX + offsetX) * scale - offsetX;
+    centerY = (centerY + offsetY) * scale - offsetY;
+    zoom = newZoom;
+    dirty = true;
+    updateWanted();
+}
+
+void MapView::zoomBy(int steps, int anchorX, int anchorY) {
+    const int target = std::min(std::max(zoom + steps, 0), MAX_VIEW_ZOOM);
+    if (target == zoom) {
+        return;
+    }
+    if (!smoothZoom()) {
+        animation.active = false;
+        io.hold(false);
+        setZoom(target, anchorX, anchorY);
+        return;
+    }
+    // Where the animation shows the map now: the current scale, or 1 when none runs. A second press during an
+    // animation starts from what is on screen.
+    const uint32_t now = nowMs();
+    float scale = 1.0f;
+    double anchorWorldX;
+    double anchorWorldY;
+    screenToWorldOffset(anchorX - width / 2.0, anchorY - height / 2.0, anchorWorldX, anchorWorldY);
+    double worldX = centerX + anchorWorldX;
+    double worldY = centerY + anchorWorldY;
+    if (animation.active) {
+        const float t = std::min(1.0f, static_cast<float>(now - animation.startMs) / ZOOM_ANIMATION_MS);
+        const float eased = 1.0f - (1.0f - t) * (1.0f - t);
+        scale = powf(animation.fromScale, 1.0f - eased);
+        double movedX;
+        double movedY;
+        screenToWorldOffset((anchorX - animation.anchorX) / scale, (anchorY - animation.anchorY) / scale, movedX, movedY);
+        worldX = animation.worldX + movedX;
+        worldY = animation.worldY + movedY;
+    }
+    // The world point under the anchor stays there through the animation and after it
+    const double factor = std::ldexp(1.0, target - zoom);
+    const double worldSize = std::ldexp(static_cast<double>(TILE_SIZE), target);
+    worldX *= factor;
+    worldY *= factor;
+    centerX = std::fmod(worldX - anchorWorldX + worldSize, worldSize);
+    centerY = std::fmin(std::fmax(worldY - anchorWorldY, 0.0), worldSize);
+    animation.active = true;
+    io.hold(true);
+    animation.startMs = now;
+    animation.fromScale = scale / static_cast<float>(factor);
+    animation.anchorX = static_cast<float>(anchorX);
+    animation.anchorY = static_cast<float>(anchorY);
+    animation.worldX = worldX;
+    animation.worldY = worldY;
+    animation.frames = 0;
+    animation.composeMs = 0;
+    animation.slowestFrameMs = 0;
+    animation.slowestLockMs = 0;
+    animation.slowestComposeMs = 0;
+    zoom = target;
+    dirty = true;
+    // The tiles of the new level are asked for when the animation ends: their reads from the card hold the SPI bus
+    // the T-Deck's display shares, which stalled animation frames by up to 240 ms
+}
+
+void MapView::screenToWorldOffset(double sx, double sy, double& wx, double& wy) const {
+    wx = bearingCos * sx - bearingSin * sy;
+    wy = bearingSin * sx + bearingCos * sy;
+}
+
+void MapView::worldToScreenOffset(double wx, double wy, double& sx, double& sy) const {
+    sx = bearingCos * wx + bearingSin * wy;
+    sy = -bearingSin * wx + bearingCos * wy;
+}
+
+void MapView::viewBounds(double& left, double& top, double& right, double& bottom) const {
+    // The world box around the four turned screen corners
+    const double halfWidth = width / 2.0;
+    const double halfHeight = height / 2.0;
+    const double spanX = std::fabs(bearingCos) * halfWidth + std::fabs(bearingSin) * halfHeight;
+    const double spanY = std::fabs(bearingSin) * halfWidth + std::fabs(bearingCos) * halfHeight;
+    left = centerX - spanX;
+    right = centerX + spanX;
+    top = centerY - spanY;
+    bottom = centerY + spanY;
+}
+
+void MapView::applyBearing(float degrees, bool want) {
+    degrees -= 360.0f * std::floor(degrees / 360.0f);
+    // Within a tenth of a degree of north is north, so the fast unturned drawing comes back
+    if (degrees < 0.1f || degrees > 359.9f) {
+        degrees = 0.0f;
+    }
+    if (degrees == bearing) {
+        return;
+    }
+    bearing = degrees;
+    const float radians = degrees * 0.017453292f;
+    bearingCos = degrees == 0.0f ? 1.0f : std::cos(radians);
+    bearingSin = degrees == 0.0f ? 0.0f : std::sin(radians);
+    dirty = true;
+    if (want) {
+        updateWanted();
+    }
+}
+
+Rect MapView::compassRect() const {
+    return { width - 6 - 30, 6, 30, 30 };
+}
+
+void MapView::drawCompass() {
+    // A needle to north, red half towards it, in a round panel; only on a turned map
+    const Rect r = compassRect();
+    const float cx = r.x + r.width / 2.0f;
+    const float cy = r.y + r.height / 2.0f;
+    float shown = bearing;
+    if (turn.active) {
+        const float t = std::min(1.0f, static_cast<float>(nowMs() - turn.startMs) / TURN_ANIMATION_MS);
+        shown = turn.from + (turn.to - turn.from) * (1.0f - (1.0f - t) * (1.0f - t));
+    }
+    const float radians = shown * 0.017453292f;
+    // North on screen is the world's up turned back by the bearing
+    const float northX = -std::sin(radians);
+    const float northY = -std::cos(radians);
+    canvas.fillCircle(cx, cy, 14.0f, theme.panel);
+    canvas.ring(cx, cy, 14.0f, 1.5f, theme.text);
+    canvas.line(cx, cy, cx + northX * 10.0f, cy + northY * 10.0f, 3.0f, monochrome ? theme.text : static_cast<uint16_t>(0xD8A3));
+    canvas.line(cx, cy, cx - northX * 10.0f, cy - northY * 10.0f, 3.0f, monochrome ? theme.panel : theme.text);
+    canvas.fillCircle(cx, cy, 2.0f, theme.text);
+}
+
+void MapView::setBearing(float degrees, bool animate) {
+    // A turn already running continues from where it shows the map now
+    float current = bearing;
+    if (turn.active) {
+        const float t = std::min(1.0f, static_cast<float>(nowMs() - turn.startMs) / TURN_ANIMATION_MS);
+        current = turn.from + (turn.to - turn.from) * (1.0f - (1.0f - t) * (1.0f - t));
+        turn.active = false;
+        io.hold(false);
+    }
+    if (!animate || !smoothZoom()) {
+        applyBearing(degrees);
+        return;
+    }
+    // The shorter way round
+    float target = degrees - 360.0f * std::floor(degrees / 360.0f);
+    float delta = target - current;
+    delta -= 360.0f * std::floor((delta + 180.0f) / 360.0f);
+    if (std::fabs(delta) < 0.1f) {
+        applyBearing(target);
+        return;
+    }
+    turn.active = true;
+    // Card work waits during the turn, its reads would hold the display's shared bus
+    io.hold(true);
+    turn.from = current;
+    turn.to = current + delta;
+    turn.startMs = nowMs();
+    turn.frames = 0;
+    turn.composeMs = 0;
+    dirty = true;
+}
+
+void MapView::pan(double dx, double dy) {
+    if (dx == 0.0 && dy == 0.0) {
+        return;
+    }
+    following = false;
+    headingUp = false;
+    double worldDx;
+    double worldDy;
+    screenToWorldOffset(dx, dy, worldDx, worldDy);
+    const double worldSize = std::ldexp(static_cast<double>(TILE_SIZE), zoom);
+    centerX = std::fmod(centerX + worldDx + worldSize, worldSize);
+    centerY = std::fmin(std::fmax(centerY + worldDy, 0.0), worldSize);
+    dirty = true;
+    updateWanted();
+}
+
+bool MapView::isSmoothView() const {
+    return smooth.valid && smooth.zoom == zoom && smooth.bearing == bearing && std::fabs(smooth.centerX - centerX) < 0.01 &&
+        std::fabs(smooth.centerY - centerY) < 0.01;
+}
+
+void MapView::updateSmooth(uint32_t now) {
+    if (!isRotated() || isSmoothView() || animation.active || turn.active || pinching || isFullScreen() || now - lastInputAt < 250 ||
+        !isViewComplete()) {
+        return;
+    }
+    smooth = { true, centerX, centerY, zoom, bearing, false };
+    dirty = true;
+}
+
+void MapView::startFollowing() {
+    if (!position.hasFix()) {
+        // Location is the user's to switch on, in the menu or in Tactility's settings
+        following = false;
+        showToast(position.unavailableMessage());
+        return;
+    }
+    if (following && !headingUp) {
+        // Second press: the direction of travel up, from the GPS course while moving
+        headingUp = true;
+        headingFilter.reset();
+        showToast("Heading up");
+    } else if (following) {
+        // Third press: free again, the map keeps its turn until N or the compass
+        following = false;
+        headingUp = false;
+        dirty = true;
+        return;
+    } else {
+        following = true;
+        headingUp = false;
+        setBearing(0.0f, true);
+    }
+    centerOnPosition();
+    dirty = true;
+}
+
+void MapView::endPinch(float scale, int fromX, int fromY, int toX, int toY) {
+    pinching = false;
+    io.hold(false);
+    // Snaps to the nearest whole zoom level, the point under the fingers at the start stays under them
+    const int newZoom = snapZoom(zoom, scale, MAX_VIEW_ZOOM);
+    const double factor = std::ldexp(1.0, newZoom - zoom);
+    // pinchWorldX, pinchWorldY is the world point under (fromX, fromY) at the start; the bearing may have changed since
+    const double worldX = pinchWorldX;
+    const double worldY = pinchWorldY;
+    (void)fromX;
+    (void)fromY;
+    double toWorldX;
+    double toWorldY;
+    screenToWorldOffset(toX - width / 2.0, toY - height / 2.0, toWorldX, toWorldY);
+    const double worldSize = std::ldexp(static_cast<double>(TILE_SIZE), newZoom);
+    centerX = std::fmod(worldX * factor - toWorldX + worldSize, worldSize);
+    centerY = std::fmin(std::fmax(worldY * factor - toWorldY, 0.0), worldSize);
+    pinchTurning = false;
+    zoom = newZoom;
+    dirty = true;
+    updateWanted();
+}
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/app/MapDownloads.cpp b/Apps/Maps/main/Source/app/MapDownloads.cpp
new file mode 100644
index 0000000..35485e9
--- /dev/null
+++ b/Apps/Maps/main/Source/app/MapDownloads.cpp
@@ -0,0 +1,277 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "MapView.h"
+
+#include "../platform/Platform.h"
+
+#include <algorithm>
+#include <cstdio>
+#include <cstring>
+
+namespace maps {
+
+namespace {
+
+constexpr uint32_t STATUS_POLL_MS = 500;
+constexpr uint32_t MESSAGE_SHOW_MS = 4000;
+/** A failed download says so longer, and tries again after a while, a few times. */
+constexpr uint32_t FAILED_MESSAGE_SHOW_MS = 10000;
+constexpr uint32_t RETRY_AFTER_MS = 30000;
+constexpr int MAX_RETRIES = 3;
+constexpr uint32_t GAP_POLL_MS = 300;
+/** The message about missing detail comes back at most this often. */
+constexpr uint32_t GAP_HINT_MS = 30000;
+
+} // namespace
+
+void MapView::openDownloadCard() {
+    downloadCard.open();
+    fillDownloadCard();
+    controls.hide();
+    dirty = true;
+}
+
+void MapView::fillDownloadCard() {
+    const Downloader::Status& status = lastStatus;
+    const bool running = status.state == Downloader::State::Downloading || status.state == Downloader::State::Updating ||
+        status.state == Downloader::State::Connecting;
+    char lines[5][64];
+    const char* rows[5];
+    int count = 0;
+    auto add = [&](const char* format, auto... values) {
+        snprintf(lines[count], sizeof(lines[count]), format, values...);
+        rows[count] = lines[count];
+        count++;
+    };
+    if (running && status.total > 0) {
+        add("%s %d%%, %d of %d tiles", status.state == Downloader::State::Updating ? "Updating" : "Downloading",
+            static_cast<int>(status.done * 100 / status.total), static_cast<int>(status.done), static_cast<int>(status.total));
+        // The size so far against an estimate from the tiles done
+        char done[16];
+        char estimate[16];
+        formatBytes(status.bytes, done, sizeof(done));
+        const uint64_t total = status.done > 0 ? status.bytes * static_cast<uint64_t>(status.total) / static_cast<uint64_t>(status.done) : 0;
+        formatBytes(total, estimate, sizeof(estimate));
+        add("%s of about %s", done, status.done > 0 ? estimate : "?");
+        const double rate = transferRate.bytesPerSecond();
+        if (rate > 0.0) {
+            char speed[16];
+            formatBytes(static_cast<uint64_t>(rate), speed, sizeof(speed));
+            const int64_t left = transferRate.secondsLeft(status.bytes, total);
+            char remaining[24] = "";
+            if (left >= 0) {
+                formatDuration(left, remaining, sizeof(remaining));
+            }
+            add("%s/s%s%s", speed, left >= 0 ? ", " : "", left >= 0 ? remaining : "");
+            if (left >= 0) {
+                snprintf(lines[count - 1] + strlen(lines[count - 1]), sizeof(lines[0]) - strlen(lines[count - 1]), " left");
+            }
+        } else {
+            add("Measuring the speed...");
+        }
+    } else if (status.state == Downloader::State::Connecting) {
+        add("%s", status.message);
+    } else if (downloader.isBrowsing() && browseTotal > 0) {
+        add("Fetching detail for the screen:");
+        add("%d of %d tiles", std::min(browseDone + 1, browseTotal), browseTotal);
+        add("They are kept in Downloaded maps,");
+        add("region \"browsed\".");
+    } else if (pausedRegion[0] != '\0') {
+        add("Paused. Resume continues where it stopped.");
+    } else {
+        add("%s", status.message[0] != '\0' ? status.message : "Nothing is downloading.");
+    }
+    // Tiles fetched while browsing can't be paused or cancelled from the card, only the card closed
+    const bool browsing = !running && status.state != Downloader::State::Connecting && downloader.isBrowsing() && browseTotal > 0;
+    const char* title = browsing ? "Map detail" : statusTitle[0] != '\0' ? statusTitle : status.region;
+    downloadCard.set(title, rows, count, !running, browsing);
+    downloadCard.layout(width, height, overlay.font());
+}
+
+void MapView::handleCardButton(DownloadCard::Button button) {
+    dirty = true;
+    switch (button) {
+        case DownloadCard::Button::PauseResume: {
+            const Downloader::Status status = downloader.status();
+            const bool running = status.state == Downloader::State::Downloading || status.state == Downloader::State::Connecting;
+            if (running) {
+                snprintf(pausedRegion, sizeof(pausedRegion), "%s", status.region);
+                downloader.cancel();
+                showToast("Download paused");
+            } else if (status.state == Downloader::State::Updating) {
+                downloader.cancel();
+                showToast("Update paused, it continues in idle time");
+            } else if (pausedRegion[0] != '\0') {
+                downloader.download(pausedRegion);
+                pausedRegion[0] = '\0';
+                showToast("Download continues");
+            }
+            downloadCard.close();
+            break;
+        }
+        case DownloadCard::Button::Cancel: {
+            // Cancelling a download deletes the part already fetched, after asking
+            const Downloader::Status status = downloader.status();
+            const char* region = status.region[0] != '\0' ? status.region : pausedRegion;
+            downloadCard.close();
+            if (region[0] == '\0' || status.state == Downloader::State::Updating) {
+                downloader.cancel();
+                break;
+            }
+            snprintf(cancelRegion, sizeof(cancelRegion), "%s", region);
+            char message[96];
+            snprintf(message, sizeof(message), "Stop and delete the part of %s downloaded so far?", statusTitle[0] != '\0' ? statusTitle : region);
+            dialogPurpose = DialogPurpose::CancelDownload;
+            dialog.open(message, "Delete", true);
+            dialog.layout(width, height, overlay.font());
+            break;
+        }
+        case DownloadCard::Button::Close:
+            downloadCard.close();
+            break;
+        default:
+            break;
+    }
+}
+
+void MapView::pollDownloader(uint32_t now) {
+    TileKey arrived[Downloader::MAX_ARRIVED];
+    int arrivedCount = 0;
+    if (downloader.takeTilesChanged(arrived, arrivedCount)) {
+        worker.tilesArrived(arrived, arrivedCount);
+        dirty = true;
+    }
+    if (!resumeChecked) {
+        // A download that was interrupted continues when the map opens again
+        resumeChecked = true;
+        int unfinished = -1;
+        RegionMeta meta {};
+        auto find = [&] {
+            for (int i = 0; i < store.regionCount() && unfinished < 0; i++) {
+                if (strcmp(store.regionName(i), pausedRegion) == 0) {
+                    continue;
+                }
+                char path[PATH_MAX_LENGTH];
+                snprintf(path, sizeof(path), "%s/maps/%s/meta.json", rootPath, store.regionName(i));
+                if (readRegionMeta(path, meta) && !meta.isComplete()) {
+                    unfinished = i;
+                }
+            }
+            return true;
+        };
+        runOnCard(io, find, IoPriority::Background);
+        if (unfinished >= 0) {
+            logInfo("Continuing the download of %s at tile %d of %d", store.regionName(unfinished), static_cast<int>(meta.done), static_cast<int>(meta.total));
+            downloader.download(store.regionName(unfinished));
+        }
+    }
+    if (retryAt != 0 && static_cast<int32_t>(now - retryAt) >= 0) {
+        retryAt = 0;
+        resumeChecked = false;
+    }
+    if (now - lastStatusPoll < STATUS_POLL_MS) {
+        return;
+    }
+    lastStatusPoll = now;
+    const Downloader::Status status = downloader.status();
+    // Tile cache slots given to a large download come back once nothing downloads, and not while a search index is
+    // built (its tables grow; it was started with the memory free that it had)
+    if (status.state != Downloader::State::Connecting && status.state != Downloader::State::Downloading &&
+        status.state != Downloader::State::Updating && !downloader.isBrowsing() && worker.cacheShrunk() && !worker.isPreparing() &&
+        navigator.state() != Navigator::State::Searching && searchIndexJob.state() != SearchIndexJob::State::Busy) {
+        worker.restoreMemory();
+    }
+    downloader.browseProgress(browseDone, browseTotal);
+    if (status.region[0] != '\0' && strcmp(status.region, statusTitleOf) != 0) {
+        // The title users gave the region, not its short folder name
+        snprintf(statusTitleOf, sizeof(statusTitleOf), "%s", status.region);
+        snprintf(statusTitle, sizeof(statusTitle), "%s", status.region);
+        RegionMeta meta {};
+        char path[PATH_MAX_LENGTH];
+        snprintf(path, sizeof(path), "%s/maps/%s/meta.json", rootPath, status.region);
+        auto read = [&] { return readRegionMeta(path, meta); };
+        if (runOnCard(io, read, IoPriority::Background)) {
+            snprintf(statusTitle, sizeof(statusTitle), "%s", regionTitle(meta));
+        }
+    }
+    if (status.state == Downloader::State::Downloading || status.state == Downloader::State::Updating) {
+        transferRate.add(now, status.bytes);
+    } else {
+        transferRate.reset();
+    }
+    // The pill follows browsing too, and goes when it ends
+    const bool browsingNow = downloader.isBrowsing();
+    if (browsingNow != lastBrowsing || browseDone != lastBrowseDone || browseTotal != lastBrowseTotal) {
+        lastBrowsing = browsingNow;
+        lastBrowseDone = browseDone;
+        lastBrowseTotal = browseTotal;
+        dirty = true;
+    }
+    worker.setConversionsPaused(status.state == Downloader::State::Connecting || status.state == Downloader::State::Downloading ||
+        status.state == Downloader::State::Updating);
+    if (status.state != lastStatus.state || status.done != lastStatus.done || strcmp(status.message, lastStatus.message) != 0) {
+        if (status.state != lastStatus.state && (status.state == Downloader::State::Done || status.state == Downloader::State::Failed)) {
+            messageUntil = now + (status.state == Downloader::State::Failed ? FAILED_MESSAGE_SHOW_MS : MESSAGE_SHOW_MS);
+        }
+        // A download that stopped on an error (the network, or memory) continues by itself a little later
+        if (status.state == Downloader::State::Failed && (lastStatus.state == Downloader::State::Downloading ||
+            lastStatus.state == Downloader::State::Connecting) && strstr(status.message, "limit") == nullptr) {
+            if (retries < MAX_RETRIES) {
+                retries++;
+                retryAt = now + RETRY_AFTER_MS;
+                logInfo("Download of %s failed, trying again in %u s (%d of %d)", status.region, RETRY_AFTER_MS / 1000, retries, MAX_RETRIES);
+            }
+        } else if (status.state == Downloader::State::Done && (lastStatus.state == Downloader::State::Downloading ||
+            lastStatus.state == Downloader::State::Connecting)) {
+            retries = 0;
+        }
+        // After a finished download the next unfinished region continues, but not one paused on purpose
+        // (a short download can go from Connecting straight to Done between two polls)
+        if (status.state == Downloader::State::Done && (lastStatus.state == Downloader::State::Downloading ||
+            lastStatus.state == Downloader::State::Connecting)) {
+            resumeChecked = false;
+        }
+        dirty = true;
+        // The Regions screen shows progress as it happens
+        if (screen == Screen::Regions && status.state == Downloader::State::Done) {
+            lastStatus = status;
+            openRegions();
+        }
+    }
+    lastStatus = status;
+    if (downloadCard.isOpen()) {
+        fillDownloadCard();
+        dirty = true;
+    }
+    if (static_cast<int32_t>(now - messageUntil) >= 0 && messageUntil != 0) {
+        messageUntil = 0;
+        dirty = true;
+    }
+}
+
+void MapView::pollGaps(uint32_t now) {
+    if (now - lastGapPoll < GAP_POLL_MS) {
+        return;
+    }
+    lastGapPoll = now;
+    TileKey gaps[8];
+    const int count = worker.takeGaps(gaps, 8);
+    if (count == 0) {
+        return;
+    }
+    if (settings.browseDownload && Downloader::isOnline()) {
+        downloader.browse(gaps, count);
+        dirty = true;
+        return;
+    }
+    if (lastGapHint != 0 && now - lastGapHint < GAP_HINT_MS) {
+        return;
+    }
+    lastGapHint = now;
+    if (!settings.browseDownload) {
+        showToast("Less detail here. Download this area for more.");
+    } else {
+        showToast("Offline: no detail here. Download this area on Wi-Fi.");
+    }
+}
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/app/MapInput.cpp b/Apps/Maps/main/Source/app/MapInput.cpp
index 3aa65f3..a4dd016 100644
--- a/Apps/Maps/main/Source/app/MapInput.cpp
+++ b/Apps/Maps/main/Source/app/MapInput.cpp
@@ -88,6 +88,12 @@ void MapView::handleKey(uint32_t key) {
             closeMenu();
             return;
         }
+        if (mainMenuOpen()) {
+            // The tile grid knows Enter and Esc, the board's yes and no keys are the same
+            const uint32_t gridKey = key == keys::YES ? keys::ENTER : (key == keys::NO ? keys::ESCAPE : key);
+            handleMainMenuEvent(menuGrid.handleKey(gridKey));
+            return;
+        }
         handleListAction(menu.handleKey(key));
         return;
     }
@@ -136,6 +142,9 @@ void MapView::pressControl(Control control) {
         case Control::Position:
             startFollowing();
             break;
+        case Control::Search:
+            openSearch();
+            break;
         default:
             break;
     }
@@ -407,7 +416,8 @@ void MapView::handleMouse(uint32_t now) {
         const int fromY = cursorY;
         moveCursor(dx, dy, now, overflowX, overflowY);
         dirty = true;
-        ListView* list = menuOpen ? &menu : activeList();
+        // The main menu is a tile grid, not a list
+        ListView* list = menuOpen ? (mainMenuOpen() ? nullptr : &menu) : activeList();
         const bool onMap = !menuOpen && !dialog.isOpen() && !prompt.isOpen() && (screen == Screen::Map || screen == Screen::Download);
         if (mouseHeld && onMap && !mouseLong) {
             // Rolling with the button held drags the map under the pointer, which stays where it is
@@ -421,6 +431,9 @@ void MapView::handleMouse(uint32_t now) {
         } else if (onMap && (overflowX != 0 || overflowY != 0)) {
             // Pushing against a screen edge moves the map that way
             pan(overflowX, overflowY);
+        } else if (mainMenuOpen() && !dialog.isOpen() && !prompt.isOpen()) {
+            // The tile under the pointer gets the focus
+            menuGrid.hover(cursorX, cursorY);
         } else if (list != nullptr && !dialog.isOpen() && !prompt.isOpen()) {
             // The row under the pointer is the highlighted one; pushing against the top or bottom scrolls the list
             const int row = list->rowAt(cursorX, cursorY);
@@ -576,7 +589,11 @@ void MapView::handleTap(int x, int y) {
         return;
     }
     if (menuOpen) {
-        handleListAction(menu.handleTap(x, y));
+        if (mainMenuOpen()) {
+            handleMainMenuEvent(menuGrid.handleTap(x, y));
+        } else {
+            handleListAction(menu.handleTap(x, y));
+        }
         gestures.consumeTap();
         return;
     }
@@ -737,6 +754,18 @@ void MapView::handleGesture(const Gesture& gesture) {
                 handleSearchEvent(searchSheet.handleDrag(gesture.dy));
             } else if (onMap) {
                 pan(-gesture.dx, -gesture.dy);
+            } else if (mainMenuOpen()) {
+                // A horizontal drag turns the pages of the tile grid, which has one page as long as the menu is this size
+                if (!dialog.isOpen() && !prompt.isOpen() && std::abs(gesture.dx) > std::abs(gesture.dy)) {
+                    dragRowAccumulator -= gesture.dx;
+                    const int pageWidth = std::max(1, width / 3);
+                    while (std::abs(dragRowAccumulator) >= pageWidth) {
+                        if (menuGrid.swipe(dragRowAccumulator > 0 ? 1 : -1)) {
+                            dirty = true;
+                        }
+                        dragRowAccumulator -= (dragRowAccumulator > 0 ? 1 : -1) * pageWidth;
+                    }
+                }
             } else if (!dialog.isOpen() && !prompt.isOpen() && std::abs(gesture.dy) >= std::abs(gesture.dx)) {
                 // Lists and the About page scroll with the finger, a row at a time; the highlight stays where it is
                 ListView* list = menuOpen ? &menu : activeList();
diff --git a/Apps/Maps/main/Source/app/MapLabels.cpp b/Apps/Maps/main/Source/app/MapLabels.cpp
new file mode 100644
index 0000000..0be2957
--- /dev/null
+++ b/Apps/Maps/main/Source/app/MapLabels.cpp
@@ -0,0 +1,203 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "MapView.h"
+
+#include "../platform/Platform.h"
+#include "../render/PoiIconData.h"
+#include "../render/PoiTypes.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+
+namespace maps {
+
+namespace {
+
+/** The icon mask of each POI type, found once by name in the generated Maki masks. */
+const uint8_t* poiIcons[256] {};
+bool poiMonochrome = false;
+uint16_t poiMonochromeColor = 0;
+
+const uint8_t* iconMask(const char* name) {
+    int low = 0;
+    int high = POI_ICON_COUNT - 1;
+    while (low <= high) {
+        const int middle = (low + high) / 2;
+        const int order = strcmp(POI_ICON_MASKS[middle].name, name);
+        if (order == 0) {
+            return POI_ICON_MASKS[middle].alpha;
+        }
+        if (order < 0) {
+            low = middle + 1;
+        } else {
+            high = middle - 1;
+        }
+    }
+    return nullptr;
+}
+
+/** Icon colours by group, dark enough to read on the light map with a white halo. */
+uint16_t groupColor(PoiGroup group) {
+    switch (group) {
+        case PoiGroup::Food: return 0xC300;      // orange
+        case PoiGroup::Shop: return 0x9113;      // purple
+        case PoiGroup::Transport: return 0x2A5A; // blue
+        case PoiGroup::Health: return 0xC104;    // red
+        case PoiGroup::Money: return 0x3A8A;     // slate
+        case PoiGroup::Lodging: return 0x0451;   // teal
+        case PoiGroup::Culture: return 0x8209;   // plum brown
+        case PoiGroup::Leisure: return 0x3445;   // green
+        case PoiGroup::Education: return 0x8A42; // brown
+        case PoiGroup::Worship: return 0x4208;   // dark grey
+        default: return 0x52AA;                  // grey
+    }
+}
+
+void preparePoiIcons(bool monochrome, uint16_t monochromeColor) {
+    poiMonochrome = monochrome;
+    poiMonochromeColor = monochromeColor;
+    const uint8_t* fallback = iconMask("marker");
+    for (int id = 1; id <= poiTypeCount() && id < 256; id++) {
+        const uint8_t* mask = iconMask(poiIconName(poiType(static_cast<uint8_t>(id)).icon));
+        poiIcons[id] = mask != nullptr ? mask : fallback;
+    }
+}
+
+bool lookupPoi(uint8_t id, PoiAppearance& out) {
+    if (id == 0 || id > poiTypeCount() || poiIcons[id] == nullptr) {
+        return false;
+    }
+    const PoiType& type = poiType(id);
+    out = { poiIcons[id], POI_ICON_SIZE, poiMonochrome ? poiMonochromeColor : groupColor(type.group), type.minZoom };
+    return true;
+}
+
+} // namespace
+
+void MapView::applyLabelFonts() {
+    LabelFont* small = labelFonts[0].isOpen() ? &labelFonts[0] : (smallFont.isOpen() ? &smallFont : &normalFont);
+    LabelFont* normal = labelFonts[1].isOpen() ? &labelFonts[1] : static_cast<LabelFont*>(&normalFont);
+    LabelFont* large = labelFonts[2].isOpen() ? &labelFonts[2] : (largeFont.isOpen() ? &largeFont : normal);
+    labels.setFonts(small, normal, large);
+}
+
+void MapView::pollLabelFonts() {
+    // Only the map loop touches the label layout: the maker's task just reports, and the files are opened here
+    if (labelFontsApplied || !fontMaker.isFinished()) {
+        return;
+    }
+    labelFontsApplied = true;
+    fontMaker.stop();
+    const unsigned written = fontMaker.writtenMask();
+    auto openWritten = [&] {
+        for (int i = 0; i < LabelFontMaker::COUNT; i++) {
+            char fontPath[200];
+            LabelFontMaker::cachePath(rootPath, i, fontPath, sizeof(fontPath));
+            if ((written & (1u << i)) != 0 && !labelFonts[i].openFile(fontPath)) {
+                logError("Label font %s does not open, the map keeps the system font", fontPath);
+            }
+        }
+        return true;
+    };
+    runOnCard(io, openWritten);
+    applyLabelFonts();
+    labelZoom = -1;
+}
+
+void MapView::applyLabelSettings() {
+    labels.setDensity(static_cast<LabelDensity>(std::clamp(settings.labels, 0, 2)));
+    preparePoiIcons(monochrome, palette->text);
+    labels.setPoiLookup(lookupPoi);
+    labels.setPreferLatin(settings.latinNames);
+    const bool binary = palette->binary;
+    // Dark names with a light halo, water in blue, peaks in brown; black on white on monochrome displays
+    labels.setStyle({ monochrome ? palette->text : static_cast<uint16_t>(0x2124), monochrome ? palette->text : static_cast<uint16_t>(0x4208),
+        monochrome ? palette->text : static_cast<uint16_t>(0x2A35), monochrome ? palette->text : static_cast<uint16_t>(0x6A04),
+        monochrome ? palette->halo : static_cast<uint16_t>(0xFFFF), binary, monochrome ? palette->text : static_cast<uint16_t>(0x7BEF) });
+    labelZoom = -1;
+}
+
+void MapView::placeLabels() {
+    const uint32_t start = nowMs();
+    double left;
+    double top;
+    double right;
+    double bottom;
+    viewBounds(left, top, right, bottom);
+    // With the map position of the screen's corner the placement does not depend on where the view was panned to
+    labels.beginTurnedView(width, height, zoom, left, top, centerX, centerY, bearingCos, bearingSin);
+    // House numbers show from z17 (z18 with few labels): only then are they read from the label files
+    labelStore.setNumbersWanted(zoom >= 17 + (settings.labels == static_cast<int>(LabelDensity::Few) ? 1 : 0));
+    const int tileCount = 1 << zoom;
+    TileKey sources[32];
+    int sourceCount = 0;
+    for (int y = static_cast<int>(std::floor(top / TILE_SIZE)); y <= static_cast<int>(std::floor((bottom - 1) / TILE_SIZE)); y++) {
+        if (y < 0 || y >= tileCount) {
+            continue;
+        }
+        for (int x = static_cast<int>(std::floor(left / TILE_SIZE)); x <= static_cast<int>(std::floor((right - 1) / TILE_SIZE)); x++) {
+            const TileKey tile { zoom, wrapTileX(x, zoom), y };
+            // The label section of the tile it was drawn from: its own up to z14, its z14 ancestor above, or a coarser
+            // one where the card has no detail
+            for (int sourceZoom = std::min(zoom, MAX_SOURCE_ZOOM); sourceZoom >= std::max(0, std::min(zoom, MAX_SOURCE_ZOOM) - 2); sourceZoom--) {
+                const TileKey source = ancestorOf(tile, sourceZoom);
+                bool known = false;
+                for (int i = 0; i < sourceCount && !known; i++) {
+                    known = sources[i] == source;
+                }
+                if (known) {
+                    break;
+                }
+                const double size = std::ldexp(static_cast<double>(TILE_SIZE), zoom - sourceZoom);
+                // The source's corner from the screen centre, from the visible tile's own column so the antimeridian
+                // does not matter, then turned onto the screen
+                const double cornerX = x * TILE_SIZE - (tile.x - (source.x << (zoom - sourceZoom))) * TILE_SIZE - centerX;
+                const double cornerY = source.y * size - centerY;
+                double screenX;
+                double screenY;
+                worldToScreenOffset(cornerX, cornerY, screenX, screenY);
+                const auto scale = static_cast<float>(size / PREPARED_EXTENT);
+                const LabelTransform transform { scale * bearingCos, scale * bearingSin, -scale * bearingSin, scale * bearingCos,
+                    static_cast<float>(width / 2.0 + screenX), static_cast<float>(height / 2.0 + screenY) };
+                const bool found = labelStore.with(source, [&](const uint8_t* bytes, size_t size, int count, const LabelCells* cells) {
+                    labels.addSection(bytes, size, count, transform, cells);
+                });
+                if (found) {
+                    if (sourceCount < 32) {
+                        sources[sourceCount++] = source;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    const uint32_t added = nowMs();
+    const int placedCount = labels.place();
+    labelCenterX = centerX;
+    labelCenterY = centerY;
+    labelZoom = zoom;
+    labelBearing = bearing;
+    lastLabelPlace = nowMs();
+    logInfo("Labels: %d placed of %d candidates (%d records) from %d tiles in %u ms (reading %u, placing %u, of that drawing %u)", placedCount,
+        labels.candidateTotal(), labels.recordsRead(), sourceCount, static_cast<unsigned>(nowMs() - start), static_cast<unsigned>(added - start),
+        static_cast<unsigned>(nowMs() - added), static_cast<unsigned>(labels.spriteMicros() / 1000));
+}
+
+void MapView::updateLabels(uint32_t now) {
+    if (!labelsReady || settings.labels == 0 || animation.active || turn.active || pinching || isFullScreen()) {
+        return;
+    }
+    // Placed again once the view settled after a change, or when tiles brought new label data; upright again after a turn
+    const bool moved = labelZoom != zoom || labelBearing != bearing || std::fabs(labelCenterX - centerX) > 0.5 ||
+        std::fabs(labelCenterY - centerY) > 0.5;
+    const bool newData = labelStore.generation() != labelGeneration;
+    // New data alone (often tiles drawn for the ring around the screen) places them again at most every 1.5 s
+    if ((!moved && !newData) || now - lastInputAt < 200 || now - lastLabelPlace < (moved ? 300u : 1500u)) {
+        return;
+    }
+    labelGeneration = labelStore.generation();
+    placeLabels();
+    dirty = true;
+}
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/app/MapNavigation.cpp b/Apps/Maps/main/Source/app/MapNavigation.cpp
index 5a9a4d7..6a108e6 100644
--- a/Apps/Maps/main/Source/app/MapNavigation.cpp
+++ b/Apps/Maps/main/Source/app/MapNavigation.cpp
@@ -35,8 +35,15 @@ double worldOfUnits(int32_t units, int zoom) {
 bool ReplaySource::load(const char* text, size_t size) {
     count = 0;
     next = 0;
-    const char* cursor = text;
-    const char* end = text + size;
+    // strstr and strtod need an end: the file's bytes have none, so the text is copied with one
+    char* copy = static_cast<char*>(largeAlloc(size + 1));
+    if (copy == nullptr) {
+        return false;
+    }
+    memcpy(copy, text, size);
+    copy[size] = '\0';
+    const char* cursor = copy;
+    const char* end = copy + size;
     while (cursor < end && count < MAX_POINTS) {
         const char* at = strstr(cursor, "<trkpt");
         if (at == nullptr || at >= end) {
@@ -55,6 +62,7 @@ bool ReplaySource::load(const char* text, size_t size) {
         }
         cursor = close + 1;
     }
+    largeFree(copy);
     setNoise(0.0f, 0.0f, 0);
     return count > 1;
 }
@@ -146,6 +154,32 @@ void MapView::navigateTo(double lat, double lon, RouteProfile profile, bool ask)
     }
 }
 
+void MapView::followGpxFile(const char* path) {
+    if (!navigator.requestTrack(path)) {
+        showToast("A route is being searched already");
+        return;
+    }
+    // Back on the map: the card of the route comes when the file is read, as for a searched route
+    stopNavigation();
+    screen = Screen::Map;
+    returnToMenu = false;
+    sheet.close();
+    recalculating = false;
+    routeRequested = true;
+    restartRoute = false;
+    startFromPosition = true;
+    trackLoading = true;
+    trackModePending = false;
+    // A track is shown as Walk until it is read: the mode kept here must say the same, or choosing the mode that was
+    // last used (Bike, say) would look like no change
+    routeProfile = RouteProfile::Walk;
+    routeCard.open("", nullptr);
+    routeCard.setMode(static_cast<int>(RouteProfile::Walk));
+    routeCard.setBusy(true);
+    routeCard.layout(width, height, sheetFont());
+    dirty = true;
+}
+
 void MapView::requestRoute(double fromLat, double fromLon, bool fromPosition, const char* toast) {
     if (!navigator.request(fromLat, fromLon, goalLat, goalLon, routeProfile)) {
         showToast("A route is being searched already");
@@ -252,18 +286,40 @@ void MapView::fillRouteCard() {
     formatDistance(route.lengthM, distance, sizeof(distance));
     formatDuration(route.seconds, time, sizeof(time));
     const RouteProfile profile = route.profile;
+    const bool track = route.track;
+    if (track) {
+        // Another mode chosen on the card searches a road route to the track's end; without a fix it starts at the
+        // track's start, not at the start of some earlier route
+        routePointTo(route.to, goalLat, goalLon);
+        routePointTo(route.points[0], startLat, startLon);
+        routeProfile = profile;
+    }
     navigator.unlock();
     char summary[64];
-    snprintf(summary, sizeof(summary), "%s \xC2\xB7 %s \xC2\xB7 %s", distance, time, routeProfileName(profile));
-    routeCard.open(summary, profile == RouteProfile::Car ? CAR_NOTE : nullptr);
+    snprintf(summary, sizeof(summary), "%s \xC2\xB7 %s \xC2\xB7 %s", distance, time, track ? "GPX track" : routeProfileName(profile));
+    routeCard.open(summary, track ? "Follows the track as it is: no turns are announced" : (profile == RouteProfile::Car ? CAR_NOTE : nullptr));
     routeCard.setMode(static_cast<int>(profile));
     routeCard.layout(width, height, sheetFont());
+    // A mode chosen while the track was read: applied now that the track's end is known
+    if (track && trackModePending) {
+        trackModePending = false;
+        if (pendingTrackMode != profile) {
+            chooseRouteMode(pendingTrackMode);
+        }
+    }
 }
 
 void MapView::chooseRouteMode(RouteProfile next) {
     routeProfile = next;
     routeCard.setMode(static_cast<int>(next));
     dirty = true;
+    if (trackLoading) {
+        // The track goes on loading: cancelling it would route to the goal of an earlier route
+        pendingTrackMode = next;
+        trackModePending = true;
+        routeCard.setBusy(true);
+        return;
+    }
     if (navigator.state() == Navigator::State::Searching) {
         // The running search stops; the new one starts when it has (updateNavigation)
         navigator.cancel();
@@ -362,6 +418,14 @@ void MapView::startNavigation() {
     navigating = true;
     arrivedAt = 0;
     lastRecalculation = 0;
+    recalculationFailed = false;
+    {
+        navigator.lock();
+        const Route& started = navigator.route();
+        scriptLog("Navigation: started, %s, %.0f m, %u points%s", routeProfileName(started.profile), started.lengthM,
+            static_cast<unsigned>(started.points.size()), started.track ? ", GPX track" : "");
+        navigator.unlock();
+    }
     navBar.showStop(true);
     layoutControls();
     char instruction[NavigationBar::INSTRUCTION_LENGTH];
@@ -384,7 +448,42 @@ void MapView::startNavigation() {
     dirty = true;
 }
 
+void MapView::flushNavLog() {
+    if (navLogUsed == 0) {
+        return;
+    }
+    char path[PATH_MAX_LENGTH];
+    char older[PATH_MAX_LENGTH];
+    snprintf(path, sizeof(path), "%s/navlog.txt", rootPath);
+    snprintf(older, sizeof(older), "%s/navlog.old", rootPath);
+    auto append = [&]() {
+        // Two files of at most 512 KB: the trip before stays readable, the card never fills
+        uint32_t size = 0;
+        if (fileSize(path, size) && size > 512 * 1024) {
+            remove(older);
+            rename(path, older);
+        }
+        FILE* file = fopen(path, "a");
+        if (file == nullptr) {
+            return false;
+        }
+        const bool ok = fwrite(navLog, 1, navLogUsed, file) == navLogUsed;
+        return fclose(file) == 0 && ok;
+    };
+    // The lines are kept when the write failed (a busy or full card) and tried again with the next ones; after a few
+    // failures in a row they are dropped, so a card that never takes them does not make every line a write
+    if (runOnCard(io, append, IoPriority::Background) || ++navLogFailures >= 3) {
+        navLogUsed = 0;
+        navLogFailures = 0;
+    }
+    navLogFlushedAt = nowMs();
+}
+
 void MapView::stopNavigation() {
+    if (navigating) {
+        scriptLog("Navigation: stopped");
+        flushNavLog();
+    }
     navigating = false;
     follower.end();
     headingUp = false;
@@ -410,6 +509,12 @@ void MapView::updateNavigation(uint32_t now) {
         const RouteResult result = navigator.takeResult();
         const bool asked = routeRequested;
         routeRequested = false;
+        // A track's result: a mode chosen meanwhile is applied by fillRouteCard (only when the track was found)
+        const bool trackResult = trackLoading;
+        trackLoading = false;
+        if (trackResult && result != RouteResult::Found) {
+            trackModePending = false;
+        }
         if (restartRoute) {
             // Another mode was chosen while it searched
             restartRoute = false;
@@ -420,7 +525,11 @@ void MapView::updateNavigation(uint32_t now) {
             if (recalculating && navigating) {
                 navigator.lock();
                 follower.begin(navigator.route());
+                const float newLength = navigator.route().lengthM;
                 navigator.unlock();
+                recalculationFailed = false;
+                scriptLog("Navigation: new route, %.0f m%s, %u ms", newLength, navigator.lastWasRejoin() ? " (back to the old route)" : "",
+                    navigator.lastStats().totalMs);
                 navBar.setMessage("New route");
             } else {
                 fillRouteCard();
@@ -428,13 +537,17 @@ void MapView::updateNavigation(uint32_t now) {
             }
         } else {
             if (recalculating && navigating) {
+                recalculationFailed = true;
+                scriptLog("Navigation: no new route: %s", routeResultText(result));
                 navBar.setMessage(routeResultText(result));
             } else {
                 // The card stays with the reason, so another mode can be tried
                 routeCard.setBusy(false);
                 routeCard.setCanStart(false);
                 routeCard.setSummary(routeResultText(result));
-                routeCard.setNote(nullptr);
+                // Between two towns the way is over the main roads of the zoomed-out map, which must be on the card
+                const bool far = (result == RouteResult::NoPath || result == RouteResult::TooLong) && navigator.lastStats().straightM > 15000;
+                routeCard.setNote(far ? "For the way between two towns, download the area between them once, zoomed out." : nullptr);
                 routeCard.layout(width, height, sheetFont());
                 if (!routeCard.isOpen()) {
                     showToast(routeResultText(result));
@@ -444,6 +557,9 @@ void MapView::updateNavigation(uint32_t now) {
         recalculating = false;
         dirty = true;
     }
+    if (navigating && navLogUsed > 0 && now - navLogFlushedAt >= 30000) {
+        flushNavLog();
+    }
     // No fix for 2 s (a GPS that stopped sending): the last one counts again, so standing still off the route is noticed
     if (navigating && static_cast<int32_t>(now - lastFollowAt) >= 2000) {
         followRoute(now);
@@ -479,14 +595,21 @@ void MapView::followRoute(uint32_t now) {
     lastFollowFixMs = fix.timeMs;
     const RouteFollower::Status status = follower.update(route, fix.latitude, fix.longitude, fix.accuracy, now, fix.course, fix.speed, newFix);
     // One line per fix while navigating, for tuning the off-route rule (0.4.1)
-    scriptLog("Follow: route %.1f m, acc %.1f m (fix %.1f), off %.1f m, heading %.0f, side %.1f m, %.1f m/s, away %u%s%s%s, replay %d",
+    // Formatted here, written after the unlock: the log is an SD write and the route lock must not wait for it
+    char logLine[224];
+    snprintf(logLine, sizeof(logLine), "Follow: route %.1f m, acc %.1f m (fix %.1f), off %.1f m, heading %.0f, side %.1f m, %.1f m/s, away %u%s%s%s, replay %d",
         status.distanceFromRouteM, status.accuracyM, fix.accuracy, status.offM, status.headingDifference, status.sideM, fix.speed,
         static_cast<unsigned>(status.awayFixes), status.awayRule != OffRouteRule::None ? " by " : "",
         status.awayRule != OffRouteRule::None ? offRouteRuleName(status.awayRule) : "", status.weakGps ? ", weak GPS" : "",
         replaying ? replay.pointIndex() : -1);
     char instruction[NavigationBar::INSTRUCTION_LENGTH];
     follower.instruction(route, instruction, sizeof(instruction));
+    const bool track = route.track;
+    if (track) {
+        snprintf(instruction, sizeof(instruction), "Follow the track");
+    }
     navigator.unlock();
+    scriptLog("%s", logLine);
     char remaining[NavigationBar::REMAINING_LENGTH];
     follower.remaining(remaining, sizeof(remaining));
     switch (status.state) {
@@ -498,16 +621,39 @@ void MapView::followRoute(uint32_t now) {
             scriptLog("Navigation: arrived");
             break;
         case RouteFollower::State::OffRoute:
-            // The first recalculation at once, then at least recalculateMs apart
-            if (!recalculating && (lastRecalculation == 0 || now - lastRecalculation >= offRouteTuning().recalculateMs) &&
-                navigator.state() == Navigator::State::Idle) {
+            if (track) {
+                // A track is followed as it is: no other way to it is searched, the bar says how far it is
+                char away[NavigationBar::INSTRUCTION_LENGTH];
+                char distance[16];
+                formatDistance(status.distanceFromRouteM, distance, sizeof(distance));
+                snprintf(away, sizeof(away), "Off the track \xC2\xB7 %s", distance);
+                navBar.set(status.nextTurn, away, remaining);
+                break;
+            }
+            // A new route at once, every time the route is left, and always from the position itself (decided
+            // 14 Nov: no waiting between new routes, no start ahead of the position). What keeps this from running
+            // in circles is that the search is short: back to the old route ahead (Navigator::requestRejoin).
+            // Only a search that found no way is not repeated before 5 s: it would fail the same way every second
+            // and keep the card and the tile cache's memory busy
+            if (!recalculating && navigator.state() == Navigator::State::Idle &&
+                (!recalculationFailed || now - lastRecalculation >= 5000)) {
                 lastRecalculation = now;
-                recalculating = navigator.request(fix.latitude, fix.longitude, goalLat, goalLon, routeProfile);
+                recalculating = navigator.requestRejoin(fix.latitude, fix.longitude, goalLat, goalLon, routeProfile, status.progressM);
                 routeRequested = recalculating;
                 scriptLog("Navigation: off route by %.0f m (acc %.1f m, off %.1f m, rule %s), recalculating", status.distanceFromRouteM,
                     status.accuracyM, status.offM, offRouteRuleName(status.firedRule));
             }
-            navBar.setMessage("Off route \xE2\x80\x94 recalculating");
+            if (recalculating) {
+                navBar.setMessage("Off route \xE2\x80\x94 recalculating");
+            } else {
+                // Not searching (the navigator is busy with something else, or the last search found no way): the bar
+                // says what is true, how far the route is
+                char away[NavigationBar::INSTRUCTION_LENGTH];
+                char distance[16];
+                formatDistance(status.distanceFromRouteM, distance, sizeof(distance));
+                snprintf(away, sizeof(away), recalculationFailed ? "Off route \xC2\xB7 %s \xC2\xB7 no new route yet" : "Off route \xC2\xB7 %s", distance);
+                navBar.set(status.nextTurn, away, remaining);
+            }
             break;
         default:
             if (!recalculating) {
diff --git a/Apps/Maps/main/Source/app/MapPlaces.cpp b/Apps/Maps/main/Source/app/MapPlaces.cpp
index 5954d9c..c010975 100644
--- a/Apps/Maps/main/Source/app/MapPlaces.cpp
+++ b/Apps/Maps/main/Source/app/MapPlaces.cpp
@@ -2,6 +2,8 @@
 // Waypoints, track recording and GPX files on the map.
 #include "MapView.h"
 
+#include "../platform/SafeFile.h"
+
 #include "../gpx/Track.h"
 #include "../render/PoiTypes.h"
 #include "../ui/Pins.h"
@@ -85,7 +87,10 @@ void MapView::loadWaypoints() {
     char path[PATH_MAX_LENGTH];
     snprintf(path, sizeof(path), "%s/waypoints.gpx", rootPath);
     FileBuffer file;
-    auto read = [&] { return file.load(path); };
+    auto read = [&] {
+        recoverFile(path);
+        return file.load(path);
+    };
     if (runOnCard(io, read, IoPriority::Background) &&
         !waypoints.load(reinterpret_cast<const char*>(file.bytes()), file.size())) {
         logError("waypoints.gpx is damaged, %d waypoints read", waypoints.count());
@@ -321,10 +326,6 @@ int MapView::waypointAt(int x, int y) const {
 }
 
 void MapView::openWaypoints() {
-    if (waypoints.count() == 0) {
-        showToast(input.hasTouch() ? "No waypoints yet: hold the map, or Menu, Add waypoint" : "No waypoints yet: P, or Menu, Add waypoint");
-        return;
-    }
     fillWaypointList();
     waypointList.select(0);
     waypointList.setHighlighted(false);
@@ -332,13 +333,40 @@ void MapView::openWaypoints() {
     dirty = true;
 }
 
+void MapView::addWaypointHere() {
+    // The sheet belongs to the map, so the list closes once it is open (not when the limit stopped it)
+    openNewWaypoint(worldYToLat(centerY, zoom), worldXToLon(centerX, zoom));
+    if (sheet.isOpen()) {
+        returnToMenu = false;
+        closeScreen();
+    }
+}
+
+void MapView::drawWaypointsEmpty(Canvas& canvas, const UiTheme& theme) {
+    // Under the "Add waypoint here" row, which is the first row of the list
+    int rowTop = 0;
+    while (rowTop < height && waypointList.rowAt(width / 2, rowTop) != 0) {
+        rowTop++;
+    }
+    const char* text = "No waypoints yet. Hold the map to add one.";
+    Font* font = &overlay.font();
+    if (font->textWidth(text) > width - 16) {
+        font = &overlay.smallFont();
+    }
+    const int x = (width - font->textWidth(text)) / 2;
+    font->drawText(canvas, std::max(8, x), rowTop + waypointList.rowHeight() + 12, text, theme.muted);
+}
+
 void MapView::fillWaypointList() {
     waypointList.clear();
     waypointList.setTitle("Waypoints");
     const double lat = position.hasFix() ? position.fix().latitude : worldYToLat(centerY, zoom);
     const double lon = position.hasFix() ? position.fix().longitude : worldXToLon(centerX, zoom);
-    const int count = waypoints.sortedByDistance(lat, lon, waypointRows, ListView::MAX_ITEMS);
-    for (int row = 0; row < count; row++) {
+    // Row 0 adds a waypoint, so the waypoints start at row 1 (waypointRows[0] stays -1)
+    waypointList.add("Add waypoint here");
+    waypointRows[0] = -1;
+    const int count = waypoints.sortedByDistance(lat, lon, waypointRows + 1, ListView::MAX_ITEMS - 1);
+    for (int row = 1; row <= count; row++) {
         const Waypoint& waypoint = waypoints.at(waypointRows[row]);
         char detail[ListView::TEXT_LENGTH];
         describeDistance(waypoint.lat, waypoint.lon, detail, sizeof(detail));
@@ -354,6 +382,9 @@ void MapView::goToWaypoint() {
         return;
     }
     const int index = waypointRows[row];
+    if (index < 0) {
+        return;
+    }
     following = false;
     centerOn(waypoints.at(index).lat, waypoints.at(index).lon, std::max(zoom, 14));
     returnToMenu = false;
@@ -369,7 +400,7 @@ int MapView::listedWaypoint() const {
 
 void MapView::openWaypointActions() {
     const int row = waypointList.selected();
-    if (row < 0 || row >= waypointList.count()) {
+    if (row < 1 || row >= waypointList.count()) {
         return;
     }
     beginPopup(Popup::WaypointActions, waypoints.at(waypointRows[row]).name);
@@ -425,10 +456,7 @@ void MapView::deleteWaypoint() {
     if (screen != Screen::Waypoints) {
         return;
     }
-    if (waypoints.count() == 0) {
-        closeScreen();
-        return;
-    }
+    // The list stays, also when it was the last waypoint: its first row adds one
     const int row = waypointList.selected();
     fillWaypointList();
     waypointList.select(std::min(row, waypointList.count() - 1));
@@ -644,6 +672,10 @@ void MapView::chooseTrackMenu(int action) {
         case 4:
             returnToMenu = true;
             openTracks();
+            if (screen != Screen::Tracks) {
+                // It bailed with a toast, so there is no screen to come back from
+                returnToMenu = false;
+            }
             break;
         default:
             break;
@@ -658,28 +690,51 @@ void MapView::openTracks() {
     trackList.setTitle(title);
     char folder[PATH_MAX_LENGTH];
     snprintf(folder, sizeof(folder), "%s/tracks", rootPath);
+    // Directory order is arbitrary and the list is capped, so the newest names are kept: YYYYMMDD-HHMM.gpx sorts by date
+    constexpr int NAME_LENGTH = 32;
     struct Context {
-        ListView* list;
-        const char* folder;
-    } context { &trackList, folder };
+        char (*names)[NAME_LENGTH];
+        int count;
+    } context { new (std::nothrow) char[ListView::MAX_ITEMS][NAME_LENGTH], 0 };
+    if (context.names == nullptr) {
+        showToast("Not enough memory");
+        return;
+    }
     auto list = [&] {
         listDirectory(folder, [](const char* fileName, bool isDirectory, void* data) {
             auto* context = static_cast<Context*>(data);
             const size_t length = strlen(fileName);
-            if (isDirectory || length < 5 || strcmp(fileName + length - 4, ".gpx") != 0 || context->list->count() >= ListView::MAX_ITEMS) {
+            if (isDirectory || length < 5 || length >= NAME_LENGTH || strcmp(fileName + length - 4, ".gpx") != 0) {
                 return true;
             }
+            // Insert into the list sorted newest first
+            int at = context->count;
+            while (at > 0 && strcmp(context->names[at - 1], fileName) < 0) {
+                at--;
+            }
+            if (at >= ListView::MAX_ITEMS) {
+                return true;
+            }
+            const int last = std::min(context->count, ListView::MAX_ITEMS - 1);
+            for (int i = last; i > at; i--) {
+                memcpy(context->names[i], context->names[i - 1], NAME_LENGTH);
+            }
+            memcpy(context->names[at], fileName, length + 1);
+            context->count = std::min(context->count + 1, ListView::MAX_ITEMS);
+            return true;
+        }, &context);
+        for (int i = 0; i < context.count; i++) {
             char path[PATH_MAX_LENGTH];
-            snprintf(path, sizeof(path), "%s/%s", context->folder, fileName);
+            snprintf(path, sizeof(path), "%s/%s", folder, context.names[i]);
             struct stat info {};
             char detail[ListView::TEXT_LENGTH];
             snprintf(detail, sizeof(detail), "%.1f KB", stat(path, &info) == 0 ? info.st_size / 1024.0 : 0.0);
-            context->list->add(fileName, detail);
-            return true;
-        }, &context);
+            trackList.add(context.names[i], detail);
+        }
         return true;
     };
     runOnCard(io, list, IoPriority::Background);
+    delete[] context.names;
     if (trackList.count() == 0) {
         showToast("No tracks yet");
         return;
@@ -751,6 +806,34 @@ void MapView::openGpxFiles() {
     dirty = true;
 }
 
+void MapView::openGpxActions() {
+    const int index = gpxList.selected();
+    if (index < 0 || index >= gpxFileCount) {
+        return;
+    }
+    beginPopup(Popup::GpxActions, gpxFiles[index].name);
+    // 0 show or hide, 1 follow
+    menu.add(gpxFiles[index].shown ? "Hide on the map" : "Show on the map");
+    popupActions[popupActionCount++] = 0;
+    menu.add("Follow this track");
+    popupActions[popupActionCount++] = 1;
+    layoutPopup();
+}
+
+void MapView::chooseGpxAction(int action) {
+    const int index = gpxList.selected();
+    if (index < 0 || index >= gpxFileCount) {
+        return;
+    }
+    if (action == 0) {
+        toggleGpxFile();
+        return;
+    }
+    char path[PATH_MAX_LENGTH];
+    snprintf(path, sizeof(path), "%s/%s", gpxFolder, gpxFiles[index].name);
+    followGpxFile(path);
+}
+
 void MapView::toggleGpxFile() {
     const int index = gpxList.selected();
     if (index < 0 || index >= gpxFileCount) {
diff --git a/Apps/Maps/main/Source/app/MapScreens.cpp b/Apps/Maps/main/Source/app/MapScreens.cpp
index a70e0a5..ef0baad 100644
--- a/Apps/Maps/main/Source/app/MapScreens.cpp
+++ b/Apps/Maps/main/Source/app/MapScreens.cpp
@@ -21,8 +21,25 @@ constexpr int MENU_WIDTH = 220;
 constexpr int ABOUT_LINES = 40;
 constexpr int ABOUT_LINE_LENGTH = 64;
 
-const char* const MENU_LABELS[] = { "Download map", "Downloaded maps", "Waypoints", "Add waypoint", "Record track", "GPX files", "Location", "Settings",
-    "About and licences", "Exit" };
+/** The tiles of the main menu, in grid order (left to right, top to bottom). */
+struct MenuEntry {
+    MenuAction action;
+    MenuIcon icon;
+    const char* label;
+};
+
+const MenuEntry MENU_ENTRIES[] = {
+    { MenuAction::Search, MenuIcon::Search, "Search" },
+    { MenuAction::Download, MenuIcon::Download, "Download" },
+    { MenuAction::Maps, MenuIcon::Maps, "Maps" },
+    { MenuAction::Waypoints, MenuIcon::Waypoints, "Waypoints" },
+    { MenuAction::Track, MenuIcon::Track, "Track" },
+    { MenuAction::Gpx, MenuIcon::Gpx, "GPX" },
+    { MenuAction::Location, MenuIcon::Location, "Location" },
+    { MenuAction::Settings, MenuIcon::Settings, "Settings" },
+    { MenuAction::About, MenuIcon::About, "About" },
+};
+
 const char* const DOWNLOAD_CHOICES[] = { "Choose area", "Choose region" };
 
 const char* const ABOUT_PARAGRAPHS[] = {
@@ -41,12 +58,6 @@ const char* const ABOUT_PARAGRAPHS[] = {
     "W/S or drag to scroll. Esc, Backspace, < or a swipe to the right go back.",
 };
 
-/** The menu row with the running download's details, before the menu items. */
-constexpr int MENU_DOWNLOAD_DETAILS = 100;
-constexpr int MENU_ROUTE_SHOW = 101;
-constexpr int MENU_ROUTE_STOP = 102;
-constexpr int MENU_ROUTE_CLEAR = 103;
-
 /** What can be done with a region or a waypoint, the rows of their action popups. */
 enum RegionAction : int {
     REGION_SHOW,
@@ -130,51 +141,86 @@ void MapView::layoutPopup() {
     dirty = true;
 }
 
-void MapView::openMenu() {
-    beginPopup(Popup::Main, "Menu");
+void MapView::readMainMenuState(MainMenuState& state) {
+    state = {};
     // While a download runs or is paused its details come first, so every input reaches Pause and Cancel
     const Downloader::Status status = downloader.status();
     const bool running = status.state == Downloader::State::Downloading || status.state == Downloader::State::Updating ||
         status.state == Downloader::State::Connecting;
     if (running || pausedRegion[0] != '\0') {
-        char detail[16];
-        snprintf(detail, sizeof(detail), "%s", running ? "starting" : "paused");
+        const char* what = status.state == Downloader::State::Updating ? "Update" : "Download";
         if (running && status.total > 0) {
-            snprintf(detail, sizeof(detail), "%d%%", static_cast<int>(status.done * 100 / status.total));
+            snprintf(state.download, sizeof(state.download), "%s %d %%", what, static_cast<int>(status.done * 100 / status.total));
+        } else {
+            snprintf(state.download, sizeof(state.download), "%s %s", what, running ? "starting" : "paused");
         }
-        menu.add(status.state == Downloader::State::Updating ? "Update" : "Download", detail);
-        popupActions[popupActionCount++] = MENU_DOWNLOAD_DETAILS;
     }
     // A route: show it again, stop following it, or clear it (it is kept until then, also across restarts)
     if (navigator.hasRoute()) {
-        if (navigating) {
-            menu.add("Stop navigation");
-            popupActions[popupActionCount++] = MENU_ROUTE_STOP;
-        } else {
-            menu.add("Show route");
-            popupActions[popupActionCount++] = MENU_ROUTE_SHOW;
-        }
-        menu.add("Clear route");
-        popupActions[popupActionCount++] = MENU_ROUTE_CLEAR;
-    }
-    menu.add("Search");
-    popupActions[popupActionCount++] = static_cast<int>(MenuItem::Search);
-    int item = 0;
-    for (const char* label : MENU_LABELS) {
-        popupActions[popupActionCount++] = item++;
-        // The track entry says what it does now
-        if (strcmp(label, "Record track") == 0 && recorder.isActive()) {
-            menu.add(recorder.state() == TrackRecorder::State::Paused ? "Track (paused)" : "Track (recording)");
-        } else if (strcmp(label, "Location") == 0) {
-            menu.add(label, LocationSource::isEnabled() ? "On" : "Off");
-        } else {
-            menu.add(label);
+        state.route = navigating ? 2 : 1;
+    }
+    state.locationOn = LocationSource::isEnabled();
+    if (recorder.isActive()) {
+        state.track = recorder.state() == TrackRecorder::State::Paused ? 2 : 1;
+    }
+}
+
+void MapView::buildMainMenu() {
+    const uint16_t focus = menuGrid.focusAction();
+    const bool shown = menuGrid.focusShown();
+    readMainMenuState(menuShown);
+    menuGrid.clear();
+    menuGrid.setTitle("Menu");
+    menuGrid.setGrid(3, 3);
+    menuGrid.setCorner(static_cast<uint16_t>(MenuAction::Exit), "Exit");
+    // Only a board with a typing keyboard has keys to tell about; touch and trackball need no explanation
+    menuGrid.setHint(input.hasKeyboard() ? "WASD: move  Enter: open  Esc: close" : nullptr);
+    for (const MenuEntry& entry : MENU_ENTRIES) {
+        const char* detail = nullptr;
+        if (entry.action == MenuAction::Location) {
+            detail = menuShown.locationOn ? "On" : "Off";
+        } else if (entry.action == MenuAction::Track && menuShown.track != 0) {
+            detail = menuShown.track == 2 ? "Paused" : "Recording";
         }
+        menuGrid.addTile(static_cast<uint16_t>(entry.action), entry.icon, entry.label, detail);
     }
-    layoutPopup();
+    if (menuShown.download[0] != '\0') {
+        menuGrid.addStatus(static_cast<uint16_t>(MenuAction::DownloadDetails), MenuIcon::Download, menuShown.download);
+    }
+    if (menuShown.route == 2) {
+        menuGrid.addStatus(static_cast<uint16_t>(MenuAction::RouteStop), MenuIcon::Stop, "Stop");
+    } else if (menuShown.route == 1) {
+        menuGrid.addStatus(static_cast<uint16_t>(MenuAction::RouteShow), MenuIcon::Route, "Show route");
+    }
+    if (menuShown.route != 0) {
+        menuGrid.addStatus(static_cast<uint16_t>(MenuAction::RouteClear), MenuIcon::Clear, "Clear route");
+    }
+    menuGrid.layout(width, height, overlay.font(), &overlay.smallFont());
+    menuGrid.setFocusAction(focus, shown);
+}
+
+void MapView::refreshMainMenu() {
+    MainMenuState state;
+    readMainMenuState(state);
+    if (!(state == menuShown)) {
+        buildMainMenu();
+        dirty = true;
+    }
+}
+
+void MapView::openMenu() {
+    buildMainMenu();
+    // It opens where it was left, without a highlight until the first key or trackball step
+    menuGrid.setFocusAction(lastMenuFocus, false);
+    popup = Popup::Main;
+    menuOpen = true;
+    dirty = true;
 }
 
 void MapView::closeMenu() {
+    if (mainMenuOpen()) {
+        lastMenuFocus = menuGrid.focusAction();
+    }
     menuOpen = false;
     dirty = true;
 }
@@ -188,46 +234,75 @@ void MapView::openDownloadChoice() {
     layoutPopup();
 }
 
-void MapView::chooseMenu(MenuItem item) {
-    menuOpen = false;
+void MapView::handleMainMenuEvent(const GridEvent& event) {
     dirty = true;
+    if (event.result == GridResult::Chosen) {
+        chooseMenuAction(static_cast<MenuAction>(event.action));
+    } else if (event.result == GridResult::Back) {
+        closeMenu();
+    }
+}
+
+void MapView::chooseMenuAction(MenuAction action) {
+    dirty = true;
+    if (action == MenuAction::Location) {
+        // The only entry that keeps the menu open, its detail shows the new state
+        toggleLocation();
+        buildMainMenu();
+        return;
+    }
+    // Back from a sub-menu or a screen opens the menu on the entry it was left from
+    lastMenuFocus = static_cast<uint16_t>(action);
+    menuOpen = false;
+    switch (action) {
+        case MenuAction::DownloadDetails:
+            openDownloadCard();
+            return;
+        case MenuAction::RouteShow:
+            fillRouteCard();
+            fitRoute();
+            return;
+        case MenuAction::RouteStop:
+            stopNavigation();
+            showToast("Navigation stopped, the route stays");
+            return;
+        case MenuAction::RouteClear:
+            clearRoute();
+            return;
+        default:
+            break;
+    }
     controls.hide();
     cursorShown = false;
     // Screens opened from here go back to the menu
     returnToMenu = true;
-    switch (item) {
-        case MenuItem::Download:
+    switch (action) {
+        case MenuAction::Download:
             openDownloadChoice();
             break;
-        case MenuItem::Regions:
+        case MenuAction::Maps:
             openRegions();
             break;
-        case MenuItem::Waypoints:
+        case MenuAction::Waypoints:
             openWaypoints();
             break;
-        case MenuItem::AddWaypoint:
-            openNewWaypoint(worldYToLat(centerY, zoom), worldXToLon(centerX, zoom));
-            break;
-        case MenuItem::RecordTrack:
+        case MenuAction::Track:
             openTrackMenu();
             break;
-        case MenuItem::GpxFiles:
+        case MenuAction::Gpx:
             openGpxFiles();
             break;
-        case MenuItem::Location:
-            toggleLocation();
-            break;
-        case MenuItem::Settings:
+        case MenuAction::Settings:
             openSettings();
             break;
-        case MenuItem::About:
+        case MenuAction::About:
             openAbout();
             break;
-        case MenuItem::Search:
+        case MenuAction::Search:
             returnToMenu = false;
             openSearch();
             break;
-        case MenuItem::Exit:
+        case MenuAction::Exit:
             // The only way out by trackball or touch, LVGL's swipe back does not run while the map has the screen
             exitRequested = true;
             break;
@@ -257,23 +332,7 @@ void MapView::handlePopupAction(UiAction action) {
     const int chosen = row >= 0 && row < popupActionCount ? popupActions[row] : row;
     switch (kind) {
         case Popup::Main:
-            if (chosen == MENU_DOWNLOAD_DETAILS) {
-                closeMenu();
-                openDownloadCard();
-            } else if (chosen == MENU_ROUTE_SHOW) {
-                closeMenu();
-                fillRouteCard();
-                fitRoute();
-            } else if (chosen == MENU_ROUTE_STOP) {
-                closeMenu();
-                stopNavigation();
-                showToast("Navigation stopped, the route stays");
-            } else if (chosen == MENU_ROUTE_CLEAR) {
-                closeMenu();
-                clearRoute();
-            } else {
-                chooseMenu(static_cast<MenuItem>(chosen));
-            }
+            // The main menu is the tile grid, it never comes here
             break;
         case Popup::DownloadChoice:
             closeMenu();
@@ -287,6 +346,10 @@ void MapView::handlePopupAction(UiAction action) {
                 setBearing(0.0f, false);
             } else {
                 openCatalog(-1);
+                if (screen != Screen::Catalog) {
+                    // It bailed with a toast, so there is no screen to come back from
+                    returnToMenu = false;
+                }
             }
             break;
         case Popup::Track:
@@ -301,6 +364,10 @@ void MapView::handlePopupAction(UiAction action) {
             closeMenu();
             chooseWaypointAction(chosen);
             break;
+        case Popup::GpxActions:
+            closeMenu();
+            chooseGpxAction(chosen);
+            break;
         case Popup::RouteStart:
             closeMenu();
             chooseRouteStart(chosen);
@@ -336,14 +403,18 @@ void MapView::handleListAction(UiAction action) {
             break;
         case Screen::Waypoints:
             if (action == UiAction::Chosen) {
-                openWaypointActions();
+                if (waypointList.selected() == 0) {
+                    addWaypointHere();
+                } else {
+                    openWaypointActions();
+                }
             } else if (action == UiAction::Delete) {
                 askDeleteWaypoint(listedWaypoint());
             }
             break;
         case Screen::GpxFiles:
             if (action == UiAction::Chosen) {
-                toggleGpxFile();
+                openGpxActions();
             }
             break;
         case Screen::Settings:
@@ -388,7 +459,7 @@ void MapView::fillRegionList() {
     regionList.clear();
     regionList.setTitle("Downloaded maps");
     if (regionCount == 0) {
-        regionList.setHint("No maps yet. Menu, Download map.");
+        regionList.setHint("No maps yet. Menu, Download.");
     } else {
         setListHint(regionList, "Enter: actions  R: rename  X: delete", "Tap: actions  Swipe right: back");
     }
@@ -423,6 +494,7 @@ void MapView::openRegionActions() {
     const RegionMeta& meta = regions[regionList.selected()];
     const Downloader::Status status = downloader.status();
     const bool active = downloader.isBusy() && strcmp(status.region, meta.name) == 0;
+    snprintf(actionRegion, sizeof(actionRegion), "%s", meta.name);
     beginPopup(Popup::RegionActions, regionTitle(meta));
     auto add = [&](const char* label, int action) {
         menu.add(label);
@@ -445,10 +517,22 @@ void MapView::openRegionActions() {
 }
 
 void MapView::chooseRegionAction(int action) {
-    if (regionList.selected() >= regionCount) {
+    // The list may have been rebuilt since the popup opened, so the region is found again by its folder name
+    int found = -1;
+    for (int i = 0; i < regionCount; i++) {
+        if (strcmp(regions[i].name, actionRegion) == 0) {
+            found = i;
+            break;
+        }
+    }
+    if (found < 0) {
+        showToast("The list changed");
+        dirty = true;
         return;
     }
-    const RegionMeta& meta = regions[regionList.selected()];
+    // The steps that follow (rename, delete, update) work on the selected row
+    regionList.select(found);
+    const RegionMeta& meta = regions[found];
     switch (action) {
         case REGION_SHOW:
             returnToMenu = false;
@@ -643,11 +727,25 @@ void MapView::fillSettingList() {
     settingList.add("Labels", LABEL_DENSITIES[std::clamp(settings.labels, 0, 2)]);
     settingList.add("Latin names", settings.latinNames ? "On" : "Off");
     settingList.add("Route mode", routeProfileName(static_cast<RouteProfile>(std::clamp(settings.routeProfile, 0, 2))));
+    // In the order of SettingItem; each says what the setting does, shown for the highlighted row
+    static const char* const DESCRIPTIONS[] = {
+        "Also keep drawn tiles on the card",
+        "Packed tiles are smaller, raw ones faster",
+        "The map scales while you pinch",
+        "Fetch missing detail on Wi-Fi as you pan",
+        "How fast the trackball moves the cursor",
+        "How many place names show on the map",
+        "Show the Latin name where a place has one",
+        "The mode a new route starts with",
+    };
+    settingList.setDescriptions(DESCRIPTIONS, static_cast<int>(SettingItem::Count));
     settingList.layoutFullScreen(width, height, overlay.font());
     settingList.select(selected);
 }
 
 void MapView::toggleSetting(SettingItem item) {
+    // Kept so a failed write can be undone: the screen and the card must not disagree
+    const Settings before = settings;
     switch (item) {
         case SettingItem::SdCache:
             settings.sdCache = !settings.sdCache;
@@ -679,6 +777,8 @@ void MapView::toggleSetting(SettingItem item) {
             break;
         case SettingItem::SmoothPinch:
             if (monochrome) {
+                showToast("Not on this display");
+                dirty = true;
                 return;
             }
             settings.smoothPinch = !settings.smoothPinch;
@@ -690,6 +790,12 @@ void MapView::toggleSetting(SettingItem item) {
     snprintf(path, sizeof(path), "%s/settings.txt", rootPath);
     auto write = [&] { return writeSettings(path, settings); };
     if (!runOnCard(io, write)) {
+        // Back to what is on the card, and what the toggle applied in memory with it
+        settings = before;
+        worker.setSdCache(settings.sdCache);
+        worker.setDeflatePrepared(settings.deflatePrepared);
+        pointerAcceleration.setSpeed(settings.pointerSpeed);
+        applyLabelSettings();
         showToast("Could not save the settings");
     }
     fillSettingList();
@@ -701,17 +807,19 @@ void MapView::toggleSetting(SettingItem item) {
 
 void MapView::openAbout() {
     // From the menu it goes back there, from the attribution on the map back to the map
-    returnToMenu = menuOpen || returnToMenu;
-    controls.hide();
-    cursorShown = false;
-    aboutScroll = 0;
-    aboutLines = 0;
+    // The buffer comes first so that a failure changes nothing on screen
     if (aboutBuffer == nullptr) {
         aboutBuffer = static_cast<char*>(largeAlloc(ABOUT_LINES * ABOUT_LINE_LENGTH));
         if (aboutBuffer == nullptr) {
+            showToast("Not enough memory");
             return;
         }
     }
+    returnToMenu = menuOpen || returnToMenu;
+    controls.hide();
+    cursorShown = false;
+    aboutScroll = 0;
+    aboutLines = 0;
     screen = Screen::About;
     menuOpen = false;
     dirty = true;
diff --git a/Apps/Maps/main/Source/app/MapSearch.cpp b/Apps/Maps/main/Source/app/MapSearch.cpp
index b22e606..7ef61d5 100644
--- a/Apps/Maps/main/Source/app/MapSearch.cpp
+++ b/Apps/Maps/main/Source/app/MapSearch.cpp
@@ -2,6 +2,7 @@
 // Offline search on the map (M6): the search sheet, the region indexes on the card, opening a result.
 #include "MapView.h"
 
+#include "SearchIndexJob.h"
 #include "../platform/Platform.h"
 #include "../route/RouteSearch.h"
 
@@ -180,9 +181,9 @@ bool MapView::loadSearchIndexes() {
             return;
         }
         auto* file = new (memory) CardSearchFile(io, path);
-        // The profile and the x/y rule come from the index header (the engine reads it)
+        // The x/y rule comes from the index header (the engine reads it); the profile is the one the index was built with
         int slot = -1;
-        auto add = [&]() { slot = searchEngine->addIndex(file, region, Translit::Russian, true); };
+        auto add = [&]() { slot = searchEngine->addIndex(file, region, translitForRegion(region), true); };
         onSearchTask(searchTask, add);
         if (slot < 0) {
             logError("Search: %s does not open", path);
@@ -290,6 +291,8 @@ void MapView::openSearch() {
     }
     searchSheet.open();
     searchSheet.setTypingKeyboard(input.hasKeyboard());
+    // "Roll" only where there is a trackball to roll (a keyboard-only board moves with Tab)
+    searchSheet.setTrackball(input.hasTrackball());
     int count = 0;
     const SearchCategory* categories = SearchEngine::categories(&count);
     const char* names[SearchSheet::MAX_CATEGORIES];
@@ -313,7 +316,7 @@ void MapView::closeSearch() {
 void MapView::layoutSearch() {
     syncTouchKeyboard();
     if (touchKeyboard.isOpen()) {
-        searchSheet.layout(width, height - TouchKeyboard::heightFor(width), sheetFont(), true);
+        searchSheet.layout(width, height - TouchKeyboard::heightFor(width, height, sheetFont().lineHeight()), sheetFont(), true);
     } else {
         searchSheet.layout(width, height, sheetFont());
     }
@@ -421,6 +424,18 @@ void MapView::scriptLog(const char* format, ...) {
     va_end(arguments);
     logInfo("%s", line);
     if (!script.isActive()) {
+        // While navigating the lines go to navlog.txt, a few at a time: what the follower saw on a real trip can be
+        // read afterwards (a rerouting loop on a bus, 14 Nov, left nothing to look at)
+        if (navigating) {
+            const size_t room = sizeof(navLog) - navLogUsed;
+            const int written = snprintf(navLog + navLogUsed, room, "%u %s\n", static_cast<unsigned>(nowMs()), line);
+            if (written > 0 && static_cast<size_t>(written) < room) {
+                navLogUsed += static_cast<size_t>(written);
+            }
+            if (navLogUsed > sizeof(navLog) - 320) {
+                flushNavLog();
+            }
+        }
         return;
     }
     // Debug scripts also get the lines in scriptlog.txt with the time: measurements without a serial log
diff --git a/Apps/Maps/main/Source/app/MapView.cpp b/Apps/Maps/main/Source/app/MapView.cpp
index 926c8ab..012b5c1 100644
--- a/Apps/Maps/main/Source/app/MapView.cpp
+++ b/Apps/Maps/main/Source/app/MapView.cpp
@@ -1,11 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "MapView.h"
+#include "MapViewInternal.h"
+
+#include "../ui/Metrics.h"
 
 #include <app/paths.h>
 
 #include "../platform/Platform.h"
 #include "../render/Compose.h"
-#include "../render/PoiIconData.h"
 #include "../render/PoiTypes.h"
 
 #include <lvgl.h>
@@ -17,6 +19,7 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 #include <esp_heap_caps.h>
+#include <esp_system.h>
 #include <esp_timer.h>
 
 #include <algorithm>
@@ -34,8 +37,6 @@ namespace {
  */
 constexpr int TILE_CACHE_SLOTS = 20;
 constexpr uint32_t LOOP_INTERVAL_MS = 15;
-/** How long a +/- or double tap zoom step is animated. */
-constexpr float ZOOM_ANIMATION_MS = 220.0f;
 constexpr uint32_t POINTER_HIDE_MS = 3000;
 /** Idle-time updates start after this long without input, on Wi-Fi, charging or above UPDATE_MIN_BATTERY percent. */
 constexpr uint32_t UPDATE_IDLE_MS = 30000;
@@ -50,17 +51,8 @@ constexpr uint32_t IDLE_AFTER_MS = 1000;
 /** Location is read on each signal of the location service, and every few seconds to notice it being switched off. */
 constexpr uint32_t LOCATION_CHECK_MS = 3000;
 constexpr uint32_t TOAST_SHOW_MS = 3500;
-constexpr uint32_t STATUS_POLL_MS = 500;
-constexpr uint32_t MESSAGE_SHOW_MS = 4000;
-/** A failed download says so longer, and tries again after a while, a few times. */
-constexpr uint32_t FAILED_MESSAGE_SHOW_MS = 10000;
-constexpr uint32_t RETRY_AFTER_MS = 30000;
-constexpr int MAX_RETRIES = 3;
 constexpr uint32_t ENTER_RELEASE_MS = 150;
-constexpr uint32_t GAP_POLL_MS = 300;
 constexpr uint32_t SLOW_LOOP_MS = 150;
-/** The message about missing detail comes back at most this often. */
-constexpr uint32_t GAP_HINT_MS = 30000;
 constexpr uint32_t LONG_PRESS_MS = 600;
 constexpr const char* NORMAL_FONTS[] = { "text_default_", "mono_mono_", "text_small_" };
 constexpr const char* SMALL_FONTS[] = { "text_small_" };
@@ -69,69 +61,6 @@ constexpr int MIN_LINE_HEIGHT = 15;
 
 } // namespace
 
-namespace {
-
-/** The icon mask of each POI type, found once by name in the generated Maki masks. */
-const uint8_t* poiIcons[256] {};
-bool poiMonochrome = false;
-uint16_t poiMonochromeColor = 0;
-
-const uint8_t* iconMask(const char* name) {
-    int low = 0;
-    int high = POI_ICON_COUNT - 1;
-    while (low <= high) {
-        const int middle = (low + high) / 2;
-        const int order = strcmp(POI_ICON_MASKS[middle].name, name);
-        if (order == 0) {
-            return POI_ICON_MASKS[middle].alpha;
-        }
-        if (order < 0) {
-            low = middle + 1;
-        } else {
-            high = middle - 1;
-        }
-    }
-    return nullptr;
-}
-
-/** Icon colours by group, dark enough to read on the light map with a white halo. */
-uint16_t groupColor(PoiGroup group) {
-    switch (group) {
-        case PoiGroup::Food: return 0xC300;      // orange
-        case PoiGroup::Shop: return 0x9113;      // purple
-        case PoiGroup::Transport: return 0x2A5A; // blue
-        case PoiGroup::Health: return 0xC104;    // red
-        case PoiGroup::Money: return 0x3A8A;     // slate
-        case PoiGroup::Lodging: return 0x0451;   // teal
-        case PoiGroup::Culture: return 0x8209;   // plum brown
-        case PoiGroup::Leisure: return 0x3445;   // green
-        case PoiGroup::Education: return 0x8A42; // brown
-        case PoiGroup::Worship: return 0x4208;   // dark grey
-        default: return 0x52AA;                  // grey
-    }
-}
-
-void preparePoiIcons(bool monochrome, uint16_t monochromeColor) {
-    poiMonochrome = monochrome;
-    poiMonochromeColor = monochromeColor;
-    const uint8_t* fallback = iconMask("marker");
-    for (int id = 1; id <= poiTypeCount() && id < 256; id++) {
-        const uint8_t* mask = iconMask(poiIconName(poiType(static_cast<uint8_t>(id)).icon));
-        poiIcons[id] = mask != nullptr ? mask : fallback;
-    }
-}
-
-bool lookupPoi(uint8_t id, PoiAppearance& out) {
-    if (id == 0 || id > poiTypeCount() || poiIcons[id] == nullptr) {
-        return false;
-    }
-    const PoiType& type = poiType(id);
-    out = { poiIcons[id], POI_ICON_SIZE, poiMonochrome ? poiMonochromeColor : groupColor(type.group), type.minZoom };
-    return true;
-}
-
-} // namespace
-
 bool MapView::begin(Device* display, const char* root, const char* dataPath) {
     // Idle time is counted from the start, not from boot
     lastInputAt = nowMs();
@@ -239,6 +168,7 @@ bool MapView::begin(Device* display, const char* root, const char* dataPath) {
     cursorY = height / 2;
     // The overlay adapts to the inputs the board has: key hints with a keyboard, focus without touch or pointer
     controls.setInputs({ input.hasKeyboard(), input.hasTouch(), input.hasPointer() });
+    metrics::setKeyboard(input.hasKeyboard());
     layoutControls();
     downloadView = downloadLayout(width, height, overlay.font().lineHeight());
     downloader.setTiming(settings.devProbe);
@@ -312,6 +242,8 @@ void MapView::end() {
         }
     }
     fontMaker.stop();
+    // The probe first: it reads the state of the download, browse, I/O and render tasks, which are deleted below
+    probe.stop();
     browsedCounter.stop();
     downloader.stop();
     if (navigatorStarted) {
@@ -320,7 +252,6 @@ void MapView::end() {
     }
     worker.stop();
     io.stop();
-    probe.stop();
     location.unsubscribe();
     if (subscribed) {
         app_event_unsubscribe(&appEvents);
@@ -379,223 +310,10 @@ void MapView::squeezeMemory(size_t largest) {
         static_cast<unsigned>(heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM) / 1024));
 }
 
-void MapView::centerOn(double lat, double lon, int newZoom) {
-    zoom = newZoom;
-    centerX = lonToWorldX(lon, zoom);
-    centerY = latToWorldY(lat, zoom);
-    dirty = true;
-    updateWanted();
-}
-
 void MapView::layoutControls() {
     controls.layout(width, height, overlay.scaleBarTop(canvas), navigating ? navBar.height(sheetFont()) : 0);
 }
 
-void MapView::centerOnPosition() {
-    const PositionFix& fix = position.fix();
-    zoom = std::clamp(zoom, 0, MAX_VIEW_ZOOM);
-    centerX = lonToWorldX(fix.longitude, zoom);
-    centerY = latToWorldY(fix.latitude, zoom);
-    if (navigating) {
-        // The position at NAVIGATION_POSITION_Y of the height: the screen centre is that far ahead of it, in the
-        // direction that is up on the (turned) screen
-        double aheadX;
-        double aheadY;
-        screenToWorldOffset(0.0, height / 2.0 - height * NAVIGATION_POSITION_Y, aheadX, aheadY);
-        const double worldSize = std::ldexp(static_cast<double>(TILE_SIZE), zoom);
-        centerX = std::fmod(centerX + aheadX + worldSize, worldSize);
-        centerY = std::fmin(std::fmax(centerY + aheadY, 0.0), worldSize);
-    }
-    dirty = true;
-    updateWanted();
-}
-
-void MapView::setZoom(int newZoom, int anchorX, int anchorY) {
-    if (newZoom < 0 || newZoom > MAX_VIEW_ZOOM || newZoom == zoom) {
-        return;
-    }
-    // The world point under the anchor stays where it is on the screen
-    double offsetX;
-    double offsetY;
-    screenToWorldOffset(anchorX - width / 2.0, anchorY - height / 2.0, offsetX, offsetY);
-    const double scale = std::ldexp(1.0, newZoom - zoom);
-    centerX = (centerX + offsetX) * scale - offsetX;
-    centerY = (centerY + offsetY) * scale - offsetY;
-    zoom = newZoom;
-    dirty = true;
-    updateWanted();
-}
-
-void MapView::zoomBy(int steps, int anchorX, int anchorY) {
-    const int target = std::min(std::max(zoom + steps, 0), MAX_VIEW_ZOOM);
-    if (target == zoom) {
-        return;
-    }
-    if (!smoothZoom()) {
-        animation.active = false;
-        io.hold(false);
-        setZoom(target, anchorX, anchorY);
-        return;
-    }
-    // Where the animation shows the map now: the current scale, or 1 when none runs. A second press during an
-    // animation starts from what is on screen.
-    const uint32_t now = nowMs();
-    float scale = 1.0f;
-    double anchorWorldX;
-    double anchorWorldY;
-    screenToWorldOffset(anchorX - width / 2.0, anchorY - height / 2.0, anchorWorldX, anchorWorldY);
-    double worldX = centerX + anchorWorldX;
-    double worldY = centerY + anchorWorldY;
-    if (animation.active) {
-        const float t = std::min(1.0f, static_cast<float>(now - animation.startMs) / ZOOM_ANIMATION_MS);
-        const float eased = 1.0f - (1.0f - t) * (1.0f - t);
-        scale = powf(animation.fromScale, 1.0f - eased);
-        double movedX;
-        double movedY;
-        screenToWorldOffset((anchorX - animation.anchorX) / scale, (anchorY - animation.anchorY) / scale, movedX, movedY);
-        worldX = animation.worldX + movedX;
-        worldY = animation.worldY + movedY;
-    }
-    // The world point under the anchor stays there through the animation and after it
-    const double factor = std::ldexp(1.0, target - zoom);
-    const double worldSize = std::ldexp(static_cast<double>(TILE_SIZE), target);
-    worldX *= factor;
-    worldY *= factor;
-    centerX = std::fmod(worldX - anchorWorldX + worldSize, worldSize);
-    centerY = std::fmin(std::fmax(worldY - anchorWorldY, 0.0), worldSize);
-    animation.active = true;
-    io.hold(true);
-    animation.startMs = now;
-    animation.fromScale = scale / static_cast<float>(factor);
-    animation.anchorX = static_cast<float>(anchorX);
-    animation.anchorY = static_cast<float>(anchorY);
-    animation.worldX = worldX;
-    animation.worldY = worldY;
-    animation.frames = 0;
-    animation.composeMs = 0;
-    animation.slowestFrameMs = 0;
-    animation.slowestLockMs = 0;
-    animation.slowestComposeMs = 0;
-    zoom = target;
-    dirty = true;
-    // The tiles of the new level are asked for when the animation ends: their reads from the card hold the SPI bus
-    // the T-Deck's display shares, which stalled animation frames by up to 240 ms
-}
-
-void MapView::screenToWorldOffset(double sx, double sy, double& wx, double& wy) const {
-    wx = bearingCos * sx - bearingSin * sy;
-    wy = bearingSin * sx + bearingCos * sy;
-}
-
-void MapView::worldToScreenOffset(double wx, double wy, double& sx, double& sy) const {
-    sx = bearingCos * wx + bearingSin * wy;
-    sy = -bearingSin * wx + bearingCos * wy;
-}
-
-void MapView::viewBounds(double& left, double& top, double& right, double& bottom) const {
-    // The world box around the four turned screen corners
-    const double halfWidth = width / 2.0;
-    const double halfHeight = height / 2.0;
-    const double spanX = std::fabs(bearingCos) * halfWidth + std::fabs(bearingSin) * halfHeight;
-    const double spanY = std::fabs(bearingSin) * halfWidth + std::fabs(bearingCos) * halfHeight;
-    left = centerX - spanX;
-    right = centerX + spanX;
-    top = centerY - spanY;
-    bottom = centerY + spanY;
-}
-
-void MapView::applyBearing(float degrees, bool want) {
-    degrees -= 360.0f * std::floor(degrees / 360.0f);
-    // Within a tenth of a degree of north is north, so the fast unturned drawing comes back
-    if (degrees < 0.1f || degrees > 359.9f) {
-        degrees = 0.0f;
-    }
-    if (degrees == bearing) {
-        return;
-    }
-    bearing = degrees;
-    const float radians = degrees * 0.017453292f;
-    bearingCos = degrees == 0.0f ? 1.0f : std::cos(radians);
-    bearingSin = degrees == 0.0f ? 0.0f : std::sin(radians);
-    dirty = true;
-    if (want) {
-        updateWanted();
-    }
-}
-
-Rect MapView::compassRect() const {
-    return { width - 6 - 30, 6, 30, 30 };
-}
-
-void MapView::drawCompass() {
-    // A needle to north, red half towards it, in a round panel; only on a turned map
-    const Rect r = compassRect();
-    const float cx = r.x + r.width / 2.0f;
-    const float cy = r.y + r.height / 2.0f;
-    float shown = bearing;
-    if (turn.active) {
-        const float t = std::min(1.0f, static_cast<float>(nowMs() - turn.startMs) / TURN_ANIMATION_MS);
-        shown = turn.from + (turn.to - turn.from) * (1.0f - (1.0f - t) * (1.0f - t));
-    }
-    const float radians = shown * 0.017453292f;
-    // North on screen is the world's up turned back by the bearing
-    const float northX = -std::sin(radians);
-    const float northY = -std::cos(radians);
-    canvas.fillCircle(cx, cy, 14.0f, theme.panel);
-    canvas.ring(cx, cy, 14.0f, 1.5f, theme.text);
-    canvas.line(cx, cy, cx + northX * 10.0f, cy + northY * 10.0f, 3.0f, monochrome ? theme.text : static_cast<uint16_t>(0xD8A3));
-    canvas.line(cx, cy, cx - northX * 10.0f, cy - northY * 10.0f, 3.0f, monochrome ? theme.panel : theme.text);
-    canvas.fillCircle(cx, cy, 2.0f, theme.text);
-}
-
-void MapView::setBearing(float degrees, bool animate) {
-    // A turn already running continues from where it shows the map now
-    float current = bearing;
-    if (turn.active) {
-        const float t = std::min(1.0f, static_cast<float>(nowMs() - turn.startMs) / TURN_ANIMATION_MS);
-        current = turn.from + (turn.to - turn.from) * (1.0f - (1.0f - t) * (1.0f - t));
-        turn.active = false;
-        io.hold(false);
-    }
-    if (!animate || !smoothZoom()) {
-        applyBearing(degrees);
-        return;
-    }
-    // The shorter way round
-    float target = degrees - 360.0f * std::floor(degrees / 360.0f);
-    float delta = target - current;
-    delta -= 360.0f * std::floor((delta + 180.0f) / 360.0f);
-    if (std::fabs(delta) < 0.1f) {
-        applyBearing(target);
-        return;
-    }
-    turn.active = true;
-    // Card work waits during the turn, its reads would hold the display's shared bus
-    io.hold(true);
-    turn.from = current;
-    turn.to = current + delta;
-    turn.startMs = nowMs();
-    turn.frames = 0;
-    turn.composeMs = 0;
-    dirty = true;
-}
-
-void MapView::pan(double dx, double dy) {
-    if (dx == 0.0 && dy == 0.0) {
-        return;
-    }
-    following = false;
-    headingUp = false;
-    double worldDx;
-    double worldDy;
-    screenToWorldOffset(dx, dy, worldDx, worldDy);
-    const double worldSize = std::ldexp(static_cast<double>(TILE_SIZE), zoom);
-    centerX = std::fmod(centerX + worldDx + worldSize, worldSize);
-    centerY = std::fmin(std::fmax(centerY + worldDy, 0.0), worldSize);
-    dirty = true;
-    updateWanted();
-}
-
 void MapView::updateWanted() {
     // The visible tiles first, nearest to the centre first, then a ring around them; a turned view needs the tiles
     // of the box around it (up to its 400 px diagonal on the T-Deck)
@@ -781,7 +499,7 @@ void MapView::drawStatus() {
     } else if (static_cast<int32_t>(nowMs() - messageUntil) < 0) {
         snprintf(text, sizeof(text), "%s", status.message);
     } else if (store.regionCount() == 0) {
-        snprintf(text, sizeof(text), "No maps yet: Menu, Download map");
+        snprintf(text, sizeof(text), "No maps yet: Menu, Download");
         progress = false;
     } else {
         return;
@@ -793,254 +511,6 @@ void MapView::drawStatus() {
     }
 }
 
-void MapView::openDownloadCard() {
-    downloadCard.open();
-    fillDownloadCard();
-    controls.hide();
-    dirty = true;
-}
-
-void MapView::fillDownloadCard() {
-    const Downloader::Status& status = lastStatus;
-    const bool running = status.state == Downloader::State::Downloading || status.state == Downloader::State::Updating ||
-        status.state == Downloader::State::Connecting;
-    char lines[5][64];
-    const char* rows[5];
-    int count = 0;
-    auto add = [&](const char* format, auto... values) {
-        snprintf(lines[count], sizeof(lines[count]), format, values...);
-        rows[count] = lines[count];
-        count++;
-    };
-    if (running && status.total > 0) {
-        add("%s %d%%, %d of %d tiles", status.state == Downloader::State::Updating ? "Updating" : "Downloading",
-            static_cast<int>(status.done * 100 / status.total), static_cast<int>(status.done), static_cast<int>(status.total));
-        // The size so far against an estimate from the tiles done
-        char done[16];
-        char estimate[16];
-        formatBytes(status.bytes, done, sizeof(done));
-        const uint64_t total = status.done > 0 ? status.bytes * static_cast<uint64_t>(status.total) / static_cast<uint64_t>(status.done) : 0;
-        formatBytes(total, estimate, sizeof(estimate));
-        add("%s of about %s", done, status.done > 0 ? estimate : "?");
-        const double rate = transferRate.bytesPerSecond();
-        if (rate > 0.0) {
-            char speed[16];
-            formatBytes(static_cast<uint64_t>(rate), speed, sizeof(speed));
-            const int64_t left = transferRate.secondsLeft(status.bytes, total);
-            char remaining[24] = "";
-            if (left >= 0) {
-                formatDuration(left, remaining, sizeof(remaining));
-            }
-            add("%s/s%s%s", speed, left >= 0 ? ", " : "", left >= 0 ? remaining : "");
-            if (left >= 0) {
-                snprintf(lines[count - 1] + strlen(lines[count - 1]), sizeof(lines[0]) - strlen(lines[count - 1]), " left");
-            }
-        } else {
-            add("Measuring the speed...");
-        }
-    } else if (status.state == Downloader::State::Connecting) {
-        add("%s", status.message);
-    } else if (downloader.isBrowsing() && browseTotal > 0) {
-        add("Fetching detail for the screen:");
-        add("%d of %d tiles", std::min(browseDone + 1, browseTotal), browseTotal);
-        add("They are kept in Downloaded maps,");
-        add("region \"browsed\".");
-    } else if (pausedRegion[0] != '\0') {
-        add("Paused. Resume continues where it stopped.");
-    } else {
-        add("%s", status.message[0] != '\0' ? status.message : "Nothing is downloading.");
-    }
-    // Tiles fetched while browsing can't be paused or cancelled from the card, only the card closed
-    const bool browsing = !running && status.state != Downloader::State::Connecting && downloader.isBrowsing() && browseTotal > 0;
-    const char* title = browsing ? "Map detail" : statusTitle[0] != '\0' ? statusTitle : status.region;
-    downloadCard.set(title, rows, count, !running, browsing);
-    downloadCard.layout(width, height, overlay.font());
-}
-
-void MapView::handleCardButton(DownloadCard::Button button) {
-    dirty = true;
-    switch (button) {
-        case DownloadCard::Button::PauseResume: {
-            const Downloader::Status status = downloader.status();
-            const bool running = status.state == Downloader::State::Downloading || status.state == Downloader::State::Connecting;
-            if (running) {
-                snprintf(pausedRegion, sizeof(pausedRegion), "%s", status.region);
-                downloader.cancel();
-                showToast("Download paused");
-            } else if (status.state == Downloader::State::Updating) {
-                downloader.cancel();
-                showToast("Update paused, it continues in idle time");
-            } else if (pausedRegion[0] != '\0') {
-                downloader.download(pausedRegion);
-                pausedRegion[0] = '\0';
-                showToast("Download continues");
-            }
-            downloadCard.close();
-            break;
-        }
-        case DownloadCard::Button::Cancel: {
-            // Cancelling a download deletes the part already fetched, after asking
-            const Downloader::Status status = downloader.status();
-            const char* region = status.region[0] != '\0' ? status.region : pausedRegion;
-            downloadCard.close();
-            if (region[0] == '\0' || status.state == Downloader::State::Updating) {
-                downloader.cancel();
-                break;
-            }
-            snprintf(cancelRegion, sizeof(cancelRegion), "%s", region);
-            char message[96];
-            snprintf(message, sizeof(message), "Stop and delete the part of %s downloaded so far?", statusTitle[0] != '\0' ? statusTitle : region);
-            dialogPurpose = DialogPurpose::CancelDownload;
-            dialog.open(message, "Delete", true);
-            dialog.layout(width, height, overlay.font());
-            break;
-        }
-        case DownloadCard::Button::Close:
-            downloadCard.close();
-            break;
-        default:
-            break;
-    }
-}
-
-void MapView::pollDownloader(uint32_t now) {
-    TileKey arrived[Downloader::MAX_ARRIVED];
-    int arrivedCount = 0;
-    if (downloader.takeTilesChanged(arrived, arrivedCount)) {
-        worker.tilesArrived(arrived, arrivedCount);
-        dirty = true;
-    }
-    if (!resumeChecked) {
-        // A download that was interrupted continues when the map opens again
-        resumeChecked = true;
-        int unfinished = -1;
-        RegionMeta meta {};
-        auto find = [&] {
-            for (int i = 0; i < store.regionCount() && unfinished < 0; i++) {
-                if (strcmp(store.regionName(i), pausedRegion) == 0) {
-                    continue;
-                }
-                char path[PATH_MAX_LENGTH];
-                snprintf(path, sizeof(path), "%s/maps/%s/meta.json", rootPath, store.regionName(i));
-                if (readRegionMeta(path, meta) && !meta.isComplete()) {
-                    unfinished = i;
-                }
-            }
-            return true;
-        };
-        runOnCard(io, find, IoPriority::Background);
-        if (unfinished >= 0) {
-            logInfo("Continuing the download of %s at tile %d of %d", store.regionName(unfinished), static_cast<int>(meta.done), static_cast<int>(meta.total));
-            downloader.download(store.regionName(unfinished));
-        }
-    }
-    if (retryAt != 0 && static_cast<int32_t>(now - retryAt) >= 0) {
-        retryAt = 0;
-        resumeChecked = false;
-    }
-    if (now - lastStatusPoll < STATUS_POLL_MS) {
-        return;
-    }
-    lastStatusPoll = now;
-    const Downloader::Status status = downloader.status();
-    // Tile cache slots given to a large download come back once nothing downloads, and not while a search index is
-    // built (its tables grow; it was started with the memory free that it had)
-    if (status.state != Downloader::State::Connecting && status.state != Downloader::State::Downloading &&
-        status.state != Downloader::State::Updating && !downloader.isBrowsing() && worker.cacheShrunk() && !worker.isPreparing() &&
-        navigator.state() != Navigator::State::Searching && searchIndexJob.state() != SearchIndexJob::State::Busy) {
-        worker.restoreMemory();
-    }
-    downloader.browseProgress(browseDone, browseTotal);
-    if (status.region[0] != '\0' && strcmp(status.region, statusTitleOf) != 0) {
-        // The title users gave the region, not its short folder name
-        snprintf(statusTitleOf, sizeof(statusTitleOf), "%s", status.region);
-        snprintf(statusTitle, sizeof(statusTitle), "%s", status.region);
-        RegionMeta meta {};
-        char path[PATH_MAX_LENGTH];
-        snprintf(path, sizeof(path), "%s/maps/%s/meta.json", rootPath, status.region);
-        auto read = [&] { return readRegionMeta(path, meta); };
-        if (runOnCard(io, read, IoPriority::Background)) {
-            snprintf(statusTitle, sizeof(statusTitle), "%s", regionTitle(meta));
-        }
-    }
-    if (status.state == Downloader::State::Downloading || status.state == Downloader::State::Updating) {
-        transferRate.add(now, status.bytes);
-    } else {
-        transferRate.reset();
-    }
-    // The pill follows browsing too, and goes when it ends
-    const bool browsingNow = downloader.isBrowsing();
-    if (browsingNow != lastBrowsing || browseDone != lastBrowseDone || browseTotal != lastBrowseTotal) {
-        lastBrowsing = browsingNow;
-        lastBrowseDone = browseDone;
-        lastBrowseTotal = browseTotal;
-        dirty = true;
-    }
-    worker.setConversionsPaused(status.state == Downloader::State::Connecting || status.state == Downloader::State::Downloading ||
-        status.state == Downloader::State::Updating);
-    if (status.state != lastStatus.state || status.done != lastStatus.done || strcmp(status.message, lastStatus.message) != 0) {
-        if (status.state != lastStatus.state && (status.state == Downloader::State::Done || status.state == Downloader::State::Failed)) {
-            messageUntil = now + (status.state == Downloader::State::Failed ? FAILED_MESSAGE_SHOW_MS : MESSAGE_SHOW_MS);
-        }
-        // A download that stopped on an error (the network, or memory) continues by itself a little later
-        if (status.state == Downloader::State::Failed && (lastStatus.state == Downloader::State::Downloading ||
-            lastStatus.state == Downloader::State::Connecting) && strstr(status.message, "limit") == nullptr) {
-            if (retries < MAX_RETRIES) {
-                retries++;
-                retryAt = now + RETRY_AFTER_MS;
-                logInfo("Download of %s failed, trying again in %u s (%d of %d)", status.region, RETRY_AFTER_MS / 1000, retries, MAX_RETRIES);
-            }
-        } else if (status.state == Downloader::State::Done && lastStatus.state == Downloader::State::Downloading) {
-            retries = 0;
-        }
-        // After a finished download the next unfinished region continues, but not one paused on purpose
-        if (status.state == Downloader::State::Done && lastStatus.state == Downloader::State::Downloading) {
-            resumeChecked = false;
-        }
-        dirty = true;
-        // The Regions screen shows progress as it happens
-        if (screen == Screen::Regions && status.state == Downloader::State::Done) {
-            lastStatus = status;
-            openRegions();
-        }
-    }
-    lastStatus = status;
-    if (downloadCard.isOpen()) {
-        fillDownloadCard();
-        dirty = true;
-    }
-    if (static_cast<int32_t>(now - messageUntil) >= 0 && messageUntil != 0) {
-        messageUntil = 0;
-        dirty = true;
-    }
-}
-
-void MapView::pollGaps(uint32_t now) {
-    if (now - lastGapPoll < GAP_POLL_MS) {
-        return;
-    }
-    lastGapPoll = now;
-    TileKey gaps[8];
-    const int count = worker.takeGaps(gaps, 8);
-    if (count == 0) {
-        return;
-    }
-    if (settings.browseDownload && Downloader::isOnline()) {
-        downloader.browse(gaps, count);
-        dirty = true;
-        return;
-    }
-    if (lastGapHint != 0 && now - lastGapHint < GAP_HINT_MS) {
-        return;
-    }
-    lastGapHint = now;
-    if (!settings.browseDownload) {
-        showToast("Less detail here. Download this area for more.");
-    } else {
-        showToast("Offline: no detail here. Download this area on Wi-Fi.");
-    }
-}
-
 Rect MapView::attributionMark() const {
     if (screen == Screen::Download) {
         return downloadView.mark;
@@ -1106,131 +576,6 @@ void MapView::drawMap() {
     }
 }
 
-void MapView::applyLabelFonts() {
-    LabelFont* small = labelFonts[0].isOpen() ? &labelFonts[0] : (smallFont.isOpen() ? &smallFont : &normalFont);
-    LabelFont* normal = labelFonts[1].isOpen() ? &labelFonts[1] : static_cast<LabelFont*>(&normalFont);
-    LabelFont* large = labelFonts[2].isOpen() ? &labelFonts[2] : (largeFont.isOpen() ? &largeFont : normal);
-    labels.setFonts(small, normal, large);
-}
-
-void MapView::pollLabelFonts() {
-    // Only the map loop touches the label layout: the maker's task just reports, and the files are opened here
-    if (labelFontsApplied || !fontMaker.isFinished()) {
-        return;
-    }
-    labelFontsApplied = true;
-    fontMaker.stop();
-    const unsigned written = fontMaker.writtenMask();
-    auto openWritten = [&] {
-        for (int i = 0; i < LabelFontMaker::COUNT; i++) {
-            char fontPath[200];
-            LabelFontMaker::cachePath(rootPath, i, fontPath, sizeof(fontPath));
-            if ((written & (1u << i)) != 0 && !labelFonts[i].openFile(fontPath)) {
-                logError("Label font %s does not open, the map keeps the system font", fontPath);
-            }
-        }
-        return true;
-    };
-    runOnCard(io, openWritten);
-    applyLabelFonts();
-    labelZoom = -1;
-}
-
-void MapView::applyLabelSettings() {
-    labels.setDensity(static_cast<LabelDensity>(std::clamp(settings.labels, 0, 2)));
-    preparePoiIcons(monochrome, palette->text);
-    labels.setPoiLookup(lookupPoi);
-    labels.setPreferLatin(settings.latinNames);
-    const bool binary = palette->binary;
-    // Dark names with a light halo, water in blue, peaks in brown; black on white on monochrome displays
-    labels.setStyle({ monochrome ? palette->text : static_cast<uint16_t>(0x2124), monochrome ? palette->text : static_cast<uint16_t>(0x4208),
-        monochrome ? palette->text : static_cast<uint16_t>(0x2A35), monochrome ? palette->text : static_cast<uint16_t>(0x6A04),
-        monochrome ? palette->halo : static_cast<uint16_t>(0xFFFF), binary, monochrome ? palette->text : static_cast<uint16_t>(0x7BEF) });
-    labelZoom = -1;
-}
-
-void MapView::placeLabels() {
-    const uint32_t start = nowMs();
-    labels.beginView(width, height, zoom);
-    // House numbers show from z17 (z18 with few labels): only then are they read from the label files
-    labelStore.setNumbersWanted(zoom >= 17 + (settings.labels == static_cast<int>(LabelDensity::Few) ? 1 : 0));
-    double left;
-    double top;
-    double right;
-    double bottom;
-    viewBounds(left, top, right, bottom);
-    const int tileCount = 1 << zoom;
-    TileKey sources[32];
-    int sourceCount = 0;
-    for (int y = static_cast<int>(std::floor(top / TILE_SIZE)); y <= static_cast<int>(std::floor((bottom - 1) / TILE_SIZE)); y++) {
-        if (y < 0 || y >= tileCount) {
-            continue;
-        }
-        for (int x = static_cast<int>(std::floor(left / TILE_SIZE)); x <= static_cast<int>(std::floor((right - 1) / TILE_SIZE)); x++) {
-            const TileKey tile { zoom, wrapTileX(x, zoom), y };
-            // The label section of the tile it was drawn from: its own up to z14, its z14 ancestor above, or a coarser
-            // one where the card has no detail
-            for (int sourceZoom = std::min(zoom, MAX_SOURCE_ZOOM); sourceZoom >= std::max(0, std::min(zoom, MAX_SOURCE_ZOOM) - 2); sourceZoom--) {
-                const TileKey source = ancestorOf(tile, sourceZoom);
-                bool known = false;
-                for (int i = 0; i < sourceCount && !known; i++) {
-                    known = sources[i] == source;
-                }
-                if (known) {
-                    break;
-                }
-                const double size = std::ldexp(static_cast<double>(TILE_SIZE), zoom - sourceZoom);
-                // The source's corner from the screen centre, from the visible tile's own column so the antimeridian
-                // does not matter, then turned onto the screen
-                const double cornerX = x * TILE_SIZE - (tile.x - (source.x << (zoom - sourceZoom))) * TILE_SIZE - centerX;
-                const double cornerY = source.y * size - centerY;
-                double screenX;
-                double screenY;
-                worldToScreenOffset(cornerX, cornerY, screenX, screenY);
-                const auto scale = static_cast<float>(size / PREPARED_EXTENT);
-                const LabelTransform transform { scale * bearingCos, scale * bearingSin, -scale * bearingSin, scale * bearingCos,
-                    static_cast<float>(width / 2.0 + screenX), static_cast<float>(height / 2.0 + screenY) };
-                const bool found = labelStore.with(source, [&](const uint8_t* bytes, size_t size, int count, const LabelCells* cells) {
-                    labels.addSection(bytes, size, count, transform, cells);
-                });
-                if (found) {
-                    if (sourceCount < 32) {
-                        sources[sourceCount++] = source;
-                    }
-                    break;
-                }
-            }
-        }
-    }
-    const uint32_t added = nowMs();
-    const int placedCount = labels.place();
-    labelCenterX = centerX;
-    labelCenterY = centerY;
-    labelZoom = zoom;
-    labelBearing = bearing;
-    lastLabelPlace = nowMs();
-    logInfo("Labels: %d placed of %d candidates (%d records) from %d tiles in %u ms (reading %u, placing %u, of that drawing %u)", placedCount,
-        labels.candidateTotal(), labels.recordsRead(), sourceCount, static_cast<unsigned>(nowMs() - start), static_cast<unsigned>(added - start),
-        static_cast<unsigned>(nowMs() - added), static_cast<unsigned>(labels.spriteMicros() / 1000));
-}
-
-void MapView::updateLabels(uint32_t now) {
-    if (!labelsReady || settings.labels == 0 || animation.active || turn.active || pinching || isFullScreen()) {
-        return;
-    }
-    // Placed again once the view settled after a change, or when tiles brought new label data; upright again after a turn
-    const bool moved = labelZoom != zoom || labelBearing != bearing || std::fabs(labelCenterX - centerX) > 0.5 ||
-        std::fabs(labelCenterY - centerY) > 0.5;
-    const bool newData = labelStore.generation() != labelGeneration;
-    // New data alone (often tiles drawn for the ring around the screen) places them again at most every 1.5 s
-    if ((!moved && !newData) || now - lastInputAt < 200 || now - lastLabelPlace < (moved ? 300u : 1500u)) {
-        return;
-    }
-    labelGeneration = labelStore.generation();
-    placeLabels();
-    dirty = true;
-}
-
 void MapView::updateWork(uint32_t now) {
     const uint32_t before = work.generation();
     auto set = [&](WorkKind kind, bool running, int32_t done, int32_t total) {
@@ -1256,6 +601,8 @@ void MapView::updateWork(uint32_t now) {
         static_cast<int32_t>(lastStatus.total));
     set(WorkKind::GpxImport, gpxImport.state() == GpxImport::State::Busy, 0, 0);
     set(WorkKind::AddressIndex, searchIndexJob.state() == SearchIndexJob::State::Busy, searchIndexJob.done(), searchIndexJob.total());
+    // The index build has the idle time: no tiles are prepared in the background meanwhile (only those on screen)
+    worker.setIndexing(searchIndexJob.state() == SearchIndexJob::State::Busy);
     const int moved = downloader.movedTiles();
     set(WorkKind::MoveBrowsed, lastStatus.state == Downloader::State::Downloading && moved > 0, moved, 0);
     if (work.generation() != before) {
@@ -1291,7 +638,7 @@ void MapView::syncTouchKeyboard() {
         return;
     }
     // The text field moves up above the keyboard
-    const int above = height - TouchKeyboard::heightFor(width);
+    const int above = height - TouchKeyboard::heightFor(width, height, sheetFont().lineHeight());
     touchKeyboard.layout(width, height, sheetFont());
     if (prompt.isOpen()) {
         prompt.layout(width, above, overlay.font());
@@ -1304,20 +651,6 @@ void MapView::syncTouchKeyboard() {
     }
 }
 
-bool MapView::isSmoothView() const {
-    return smooth.valid && smooth.zoom == zoom && smooth.bearing == bearing && std::fabs(smooth.centerX - centerX) < 0.01 &&
-        std::fabs(smooth.centerY - centerY) < 0.01;
-}
-
-void MapView::updateSmooth(uint32_t now) {
-    if (!isRotated() || isSmoothView() || animation.active || turn.active || pinching || isFullScreen() || now - lastInputAt < 250 ||
-        !isViewComplete()) {
-        return;
-    }
-    smooth = { true, centerX, centerY, zoom, bearing, false };
-    dirty = true;
-}
-
 void MapView::drawScaledMap() {
     const uint32_t start = nowMs();
     AffineView view {};
@@ -1427,6 +760,9 @@ void MapView::render() {
             drawAbout();
         } else {
             activeList()->draw(canvas, overlay.font(), theme);
+            if (screen == Screen::Waypoints && waypoints.count() == 0) {
+                drawWaypointsEmpty(canvas, theme);
+            }
         }
     } else {
         drawMap();
@@ -1495,7 +831,11 @@ void MapView::render() {
         }
     }
     if (menuOpen) {
-        menu.draw(canvas, overlay.font(), theme);
+        if (mainMenuOpen()) {
+            menuGrid.draw(canvas, overlay.font(), theme);
+        } else {
+            menu.draw(canvas, overlay.font(), theme);
+        }
     }
     if (dialog.isOpen()) {
         dialog.draw(canvas, overlay.font(), theme);
@@ -1579,33 +919,6 @@ void MapView::showToast(const char* text) {
     dirty = true;
 }
 
-void MapView::startFollowing() {
-    if (!position.hasFix()) {
-        // Location is the user's to switch on, in the menu or in Tactility's settings
-        following = false;
-        showToast(position.unavailableMessage());
-        return;
-    }
-    if (following && !headingUp) {
-        // Second press: the direction of travel up, from the GPS course while moving
-        headingUp = true;
-        headingFilter.reset();
-        showToast("Heading up");
-    } else if (following) {
-        // Third press: free again, the map keeps its turn until N or the compass
-        following = false;
-        headingUp = false;
-        dirty = true;
-        return;
-    } else {
-        following = true;
-        headingUp = false;
-        setBearing(0.0f, true);
-    }
-    centerOnPosition();
-    dirty = true;
-}
-
 void MapView::toggleLocation() {
     const bool enable = !LocationSource::isEnabled();
     if (!LocationSource::setEnabled(enable)) {
@@ -1616,29 +929,6 @@ void MapView::toggleLocation() {
     readLocation();
 }
 
-void MapView::endPinch(float scale, int fromX, int fromY, int toX, int toY) {
-    pinching = false;
-    io.hold(false);
-    // Snaps to the nearest whole zoom level, the point under the fingers at the start stays under them
-    const int newZoom = snapZoom(zoom, scale, MAX_VIEW_ZOOM);
-    const double factor = std::ldexp(1.0, newZoom - zoom);
-    // pinchWorldX, pinchWorldY is the world point under (fromX, fromY) at the start; the bearing may have changed since
-    const double worldX = pinchWorldX;
-    const double worldY = pinchWorldY;
-    (void)fromX;
-    (void)fromY;
-    double toWorldX;
-    double toWorldY;
-    screenToWorldOffset(toX - width / 2.0, toY - height / 2.0, toWorldX, toWorldY);
-    const double worldSize = std::ldexp(static_cast<double>(TILE_SIZE), newZoom);
-    centerX = std::fmod(worldX * factor - toWorldX + worldSize, worldSize);
-    centerY = std::fmin(std::fmax(worldY * factor - toWorldY, 0.0), worldSize);
-    pinchTurning = false;
-    zoom = newZoom;
-    dirty = true;
-    updateWanted();
-}
-
 void MapView::readLocation() {
     lastLocationCheck = nowMs();
     const bool hadFix = position.hasFix();
@@ -1717,8 +1007,13 @@ void MapView::run() {
         if (input.takeDevicesChanged()) {
             // The trackball was switched between keyboard and mouse mode
             controls.setInputs({ input.hasKeyboard(), input.hasTouch(), input.hasPointer() });
+            metrics::setKeyboard(input.hasKeyboard());
             cursorShown = false;
             pointerAcceleration.reset();
+            // The download card's key hint comes or goes: laid out again so it does not overlap the buttons
+            if (downloadCard.isOpen()) {
+                fillDownloadCard();
+            }
             dirty = true;
         }
         const uint32_t afterKeys = nowMs();
@@ -1746,6 +1041,9 @@ void MapView::run() {
         const uint32_t afterLocation = nowMs();
         probe.phase("downloader");
         pollDownloader(now);
+        if (mainMenuOpen()) {
+            refreshMainMenu();
+        }
         pollGpxImport();
         pollSearchIndex(now);
         recorder.flushIfDue(io, now);
@@ -1843,10 +1141,65 @@ void MapView::run() {
                         logError("Off route: no value named %s", step.name);
                     }
                     break;
+                case DebugScript::Action::Pointer:
+                    cursorX = std::clamp(static_cast<int>(step.values[0]), 0, width - 1);
+                    cursorY = std::clamp(static_cast<int>(step.values[1]), 0, height - 1);
+                    cursorShown = true;
+                    cursorMovedAt = nowMs();
+                    if (mainMenuOpen()) {
+                        menuGrid.hover(cursorX, cursorY);
+                    }
+                    dirty = true;
+                    break;
+                case DebugScript::Action::FollowGpx: {
+                    char path[PATH_MAX_LENGTH];
+                    snprintf(path, sizeof(path), "%s/%s", rootPath, step.name);
+                    followGpxFile(path);
+                    break;
+                }
+                case DebugScript::Action::Restart:
+                    logInfo("debug: restarting the board");
+                    saveView();
+                    vTaskDelay(pdMS_TO_TICKS(300));
+                    esp_restart();
+                    break;
+                case DebugScript::Action::Memory: {
+                    logMemory(step.name);
+                    // The tasks that run now, by their handles (the task list of FreeRTOS is not exported to apps)
+                    struct Named {
+                        const char* name;
+                        TaskHandle_t task;
+                    };
+                    const Named tasks[] = { { "io", io.taskHandle() }, { "render0", worker.laneTask(0) }, { "render1", worker.laneTask(1) },
+                        { "download", downloader.controlTaskHandle() }, { "browse", downloader.browseTaskHandle() },
+                        { "route", navigator.taskHandle() }, { "search", searchTask.taskHandle() }, { "sidx", searchIndexJob.taskHandle() } };
+                    char line[240];
+                    int at = snprintf(line, sizeof(line), "Stack left %s: main %u", step.name,
+                        static_cast<unsigned>(uxTaskGetStackHighWaterMark(nullptr)));
+                    for (const Named& named : tasks) {
+                        if (named.task != nullptr && at < static_cast<int>(sizeof(line)) - 24) {
+                            at += snprintf(line + at, sizeof(line) - static_cast<size_t>(at), ", %s %u", named.name,
+                                static_cast<unsigned>(uxTaskGetStackHighWaterMark(named.task)));
+                        }
+                    }
+                    logInfo("%s", line);
+                    // Into the script log too: the serial line is not always there (silent after a restart, 13 Nov)
+                    scriptLog("Memory %s: internal %u free (largest %u), PSRAM %u free (largest %u)", step.name,
+                        static_cast<unsigned>(heap_caps_get_free_size(MALLOC_CAP_INTERNAL)),
+                        static_cast<unsigned>(heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL)),
+                        static_cast<unsigned>(heap_caps_get_free_size(MALLOC_CAP_SPIRAM)),
+                        static_cast<unsigned>(heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM)));
+                    scriptLog("%s", line);
+                    break;
+                }
                 case DebugScript::Action::TouchOnly:
                     input.setTouchOnly(true);
                     cursorShown = false;
                     controls.setInputs({ input.hasKeyboard(), input.hasTouch(), input.hasPointer() });
+                    metrics::setKeyboard(input.hasKeyboard());
+                    if (downloadCard.isOpen()) {
+                        fillDownloadCard();
+                    }
                     dirty = true;
                     break;
                 default:
diff --git a/Apps/Maps/main/Source/app/MapView.h b/Apps/Maps/main/Source/app/MapView.h
index 8fc9de9..4ae1740 100644
--- a/Apps/Maps/main/Source/app/MapView.h
+++ b/Apps/Maps/main/Source/app/MapView.h
@@ -44,18 +44,20 @@
 #include "../ui/Settings.h"
 #include "../ui/GpxLayer.h"
 #include "../ui/Waypoints.h"
+#include "../ui/TileGrid.h"
 #include "../ui/Widgets.h"
 
 #include <app/event.h>
 #include <tactility/device.h>
 
 #include <cstdint>
+#include <cstring>
 
 namespace maps {
 
 struct AffineScratch;
 
-#define APP_VERSION "0.5.0"
+#define APP_VERSION "0.6.0"
 constexpr const char* APP_ID = "tactility.maps";
 
 /**
@@ -88,6 +90,25 @@ class ReplaySource final : public PositionSource {
     uint32_t lastStep = 0;
 };
 
+/** What a tile, status item or the corner button of the main menu does; the grid hands it back as a number. */
+enum class MenuAction : uint16_t {
+    Search,
+    Download,
+    Maps,
+    Waypoints,
+    Track,
+    Gpx,
+    Location,
+    Settings,
+    About,
+    Exit,
+    /** The status strip: a running download, then the route. */
+    DownloadDetails,
+    RouteShow,
+    RouteStop,
+    RouteClear
+};
+
 class MapView {
 public:
     bool begin(Device* display, const char* root, const char* dataPath);
@@ -107,19 +128,17 @@ class MapView {
         Tracks
     };
 
-    enum class MenuItem : uint8_t {
-        Download,
-        Regions,
-        Waypoints,
-        AddWaypoint,
-        RecordTrack,
-        GpxFiles,
-        Location,
-        Settings,
-        About,
-        Exit,
-        Search,
-        Count
+    /** What the main menu shows apart from the fixed labels, to tell whether it has to be built again. */
+    struct MainMenuState {
+        char download[TileGrid::STATUS_LENGTH];
+        /** 0: no route, 1: Show route, 2: Stop. */
+        uint8_t route;
+        bool locationOn;
+        /** 0: no track, 1: recording, 2: paused. */
+        uint8_t track;
+        bool operator==(const MainMenuState& other) const {
+            return strcmp(download, other.download) == 0 && route == other.route && locationOn == other.locationOn && track == other.track;
+        }
     };
 
     enum class Popup : uint8_t {
@@ -128,6 +147,8 @@ class MapView {
         Track,
         RegionActions,
         WaypointActions,
+        /** A GPX file: show or hide it, follow it. */
+        GpxActions,
         /** Where a route starts when there is no GPS fix (M5c). */
         RouteStart
     };
@@ -281,7 +302,19 @@ class MapView {
     // MapScreens.cpp: menu, Regions, Settings, About, download frame
     void openMenu();
     void closeMenu();
-    void chooseMenu(MenuItem item);
+    /** The main menu is the tile grid, every other popup a ListView in menu. */
+    bool mainMenuOpen() const { return menuOpen && popup == Popup::Main; }
+    /** Fills the grid from the current state (tiles, details, status strip), keeping the focus. */
+    void buildMainMenu();
+    /** While the grid is open: builds it again when what it shows has changed. */
+    void refreshMainMenu();
+    void readMainMenuState(MainMenuState& state);
+    void handleMainMenuEvent(const GridEvent& event);
+    void chooseMenuAction(MenuAction action);
+    /** Adds a waypoint at the map centre, from the first row of the waypoint list. */
+    void addWaypointHere();
+    /** The empty waypoint list says how to add one. */
+    void drawWaypointsEmpty(Canvas& canvas, const UiTheme& theme);
     void handleListAction(UiAction action);
     /** What Enter, a click, a tap or Back did in the popup that is open. */
     void handlePopupAction(UiAction action);
@@ -395,6 +428,10 @@ class MapView {
     void openTracks();
     void openGpxFiles();
     void toggleGpxFile();
+    void openGpxActions();
+    void chooseGpxAction(int action);
+    /** Makes a route from the file's first track or route and shows its card, as for a searched route. */
+    void followGpxFile(const char* path);
     void pollGpxImport();
     void saveShownGpx();
     void loadShownGpx();
@@ -471,7 +508,20 @@ class MapView {
     bool routeRequested = false;
     /** A mode was chosen while a search ran: a new search starts once it has stopped. */
     bool restartRoute = false;
+    /** A GPX track is being read for following; a mode chosen meanwhile waits for it (fillRouteCard applies it). */
+    bool trackLoading = false;
+    bool trackModePending = false;
+    RouteProfile pendingTrackMode = RouteProfile::Walk;
     uint32_t lastRecalculation = 0;
+    /** The last recalculation gave no route: the bar says so instead of "recalculating". */
+    bool recalculationFailed = false;
+    /** Lines of the navigation log (navlog.txt) not yet on the card, and when they were written last. */
+    char navLog[3072] = "";
+    size_t navLogUsed = 0;
+    /** Failed writes of the log in a row: the lines are kept for a few tries, then dropped. */
+    uint8_t navLogFailures = 0;
+    uint32_t navLogFlushedAt = 0;
+    void flushNavLog();
     int64_t lastFollowFixMs = -1;
     uint32_t lastFollowAt = 0;
     uint32_t lastFollowSignature = 0;
@@ -495,6 +545,11 @@ class MapView {
     bool returnToMenu = false;
     /** The popup over the screen: the menu, its sub-menus, or the actions of a row in a list. */
     ListView menu;
+    /** The main menu: open when menuOpen and popup is Main. */
+    TileGrid menuGrid;
+    /** The action focused when the main menu was left, so it opens there again. */
+    uint16_t lastMenuFocus = TileGrid::NO_ACTION;
+    MainMenuState menuShown {};
     bool menuOpen = false;
     Popup popup = Popup::Main;
     static constexpr int MAX_POPUP_ACTIONS = 16;
@@ -504,6 +559,8 @@ class MapView {
     ListView regionList;
     RegionMeta regions[TileStore::MAX_REGIONS] {};
     int regionCount = 0;
+    /** The folder of the region whose actions popup is open: the list can be rebuilt while it is open. */
+    char actionRegion[REGION_NAME_MAX + 1] {};
     ListView settingList;
     ListView catalogList;
     char catalogPath[PATH_MAX_LENGTH] = "";
diff --git a/Apps/Maps/main/Source/app/MapViewInternal.h b/Apps/Maps/main/Source/app/MapViewInternal.h
new file mode 100644
index 0000000..e7f0562
--- /dev/null
+++ b/Apps/Maps/main/Source/app/MapViewInternal.h
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+namespace maps {
+
+/** How long a +/- or double tap zoom step is animated. */
+constexpr float ZOOM_ANIMATION_MS = 220.0f;
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/app/Navigator.cpp b/Apps/Maps/main/Source/app/Navigator.cpp
index 193569e..969bbf6 100644
--- a/Apps/Maps/main/Source/app/Navigator.cpp
+++ b/Apps/Maps/main/Source/app/Navigator.cpp
@@ -4,6 +4,8 @@
 #include "TileWorker.h"
 
 #include "../platform/Platform.h"
+#include "../route/RouteSplice.h"
+#include "../route/RouteTrack.h"
 #include "../tiles/TileStore.h"
 
 #include <esp_heap_caps.h>
@@ -35,6 +37,9 @@ struct GraphReadJob {
     int* lastRegion;
     uint32_t findMs;
     uint32_t readMs;
+    /** The original is on the card, in this region, but no graph was made from it yet. */
+    bool noGraph = false;
+    int region = -1;
 };
 
 bool graphReadJob(IoTask& io, void* context) {
@@ -67,6 +72,8 @@ bool graphReadJob(IoTask& io, void* context) {
             return ok;
         }
     }
+    job->noGraph = true;
+    job->region = file.region;
     return false;
 }
 
@@ -91,7 +98,7 @@ uint32_t readU32(const uint8_t* bytes) {
 /** Reads graph files through the I/O task from the region that holds the tile. */
 class Navigator::CardSource final : public GraphSource {
 public:
-    CardSource(IoTask& io, TileStore& store) : io(io), store(store) {}
+    CardSource(IoTask& io, TileStore& store, TileWorker& worker) : io(io), store(store), worker(worker) {}
     ~CardSource() override = default;
     bool readGraph(const TileKey& tile, GrowArray<uint8_t>& file) override {
         GraphReadJob job { &store, tile, &buffer, false, false, &lastRegion, 0, 0 };
@@ -107,6 +114,22 @@ class Navigator::CardSource final : public GraphSource {
             job.yielded = false;
             ok = io.run(IoPriority::Visible, graphReadJob, &job);
         }
+        if (!ok && job.noGraph && prepareLeftMs > 0 && worker.prepareForRoute(tile, job.region)) {
+            // On the card, but its graph is not made yet (a region just downloaded, or the z10 tiles of the
+            // main-road layer after an update): made now, and the search waits for it. Not without end: a route
+            // through a whole new region would wait minutes, so after PREPARE_MS in all the tiles count as missing
+            // (the idle time prepares them, and a later search has them)
+            const uint32_t waitStart = nowMs();
+            while (worker.isPreparingTile(tile) && nowMs() - waitStart < std::min<uint32_t>(prepareLeftMs, PREPARE_TILE_MS)) {
+                vTaskDelay(pdMS_TO_TICKS(50));
+            }
+            const uint32_t waited = nowMs() - waitStart;
+            prepareLeftMs = waited < prepareLeftMs ? prepareLeftMs - waited : 0;
+            prepared++;
+            job.noGraph = false;
+            ok = io.run(IoPriority::Visible, graphReadJob, &job);
+            logInfo("Route: graph of %d/%d/%d made for the search in %u ms%s", tile.z, tile.x, tile.y, static_cast<unsigned>(waited), ok ? "" : ", not there");
+        }
         if (!ok || !file.resize(buffer.size())) {
             readFailures++;
             logInfo("Route: no graph for %d/%d/%d (%s, yielded %d, %u bytes short, largest free block %u KB)", tile.z, tile.x, tile.y,
@@ -123,10 +146,17 @@ class Navigator::CardSource final : public GraphSource {
         return heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM) < 256 * 1024 || heap_caps_get_free_size(MALLOC_CAP_SPIRAM) < 768 * 1024;
     }
     int readFailures = 0;
+    /** Graphs made because the search asked for them. */
+    int prepared = 0;
 
 private:
+    /** The longest a search waits for graphs to be made, in all and for one tile. */
+    static constexpr uint32_t PREPARE_MS = 60000;
+    static constexpr uint32_t PREPARE_TILE_MS = 10000;
+    uint32_t prepareLeftMs = PREPARE_MS;
     IoTask& io;
     TileStore& store;
+    TileWorker& worker;
     FileBuffer buffer;
     int lastRegion = -1;
 };
@@ -198,12 +228,89 @@ bool Navigator::request(double fromLat, double fromLon, double toLat, double toL
     requestTo[0] = toLat;
     requestTo[1] = toLon;
     requestProfile = profile;
+    requestProgress = -1.0f;
+    currentState = State::Searching;
+    job = Job::Route;
+    xSemaphoreGive(wake);
+    return true;
+}
+
+bool Navigator::requestRejoin(double fromLat, double fromLon, double toLat, double toLon, RouteProfile profile, float progressM) {
+    if (task == nullptr || currentState == State::Searching) {
+        return false;
+    }
+    requestFrom[0] = fromLat;
+    requestFrom[1] = fromLon;
+    requestTo[0] = toLat;
+    requestTo[1] = toLon;
+    requestProfile = profile;
+    requestProgress = progressM;
     currentState = State::Searching;
     job = Job::Route;
     xSemaphoreGive(wake);
     return true;
 }
 
+bool Navigator::runRejoin(GraphSource& source, Route& next) {
+    // "Clear route" on the main task can empty the current route at any time: what is needed of it is read under the
+    // lock, and the splice is made under the lock only if the route has not changed since
+    // Far enough ahead that the way back is no U-turn, near enough that the search is short
+    const float ahead = requestProfile == RouteProfile::Walk ? 400.0f : 1200.0f;
+    const RoutePoint from = routePointFrom(requestFrom[0], requestFrom[1]);
+    lock();
+    const uint32_t generation = changes.load();
+    const Route& current0 = routes[current];
+    const size_t target = current0.isEmpty() ? SIZE_MAX : rejoinTarget(current0, from, requestProgress, ahead, 1000.0f);
+    const RoutePoint join = target != SIZE_MAX ? current0.points[target] : RoutePoint {};
+    const RoutePoint destination = current0.to;
+    unlock();
+    if (target == SIZE_MAX) {
+        return false;
+    }
+    double targetLat;
+    double targetLon;
+    routePointTo(join, targetLat, targetLon);
+    Route piece;
+    RouteStats pieceStats {};
+    const RouteResult found = search.find(source, requestFrom[0], requestFrom[1], targetLat, targetLon, requestProfile, piece, &pieceStats);
+    if (found != RouteResult::Found) {
+        rejoinCancelled = found == RouteResult::Cancelled;
+        logInfo("Route rejoin: %s in %u ms%s", routeResultText(found), pieceStats.totalMs, rejoinCancelled ? "" : ", searching to the destination");
+        return false;
+    }
+    // A way back that is far longer than the straight line is no way back (a river, a motorway in between)
+    const float dx = static_cast<float>(join.x - from.x);
+    const float dy = static_cast<float>(join.y - from.y);
+    const float straight = std::sqrt(dx * dx + dy * dy) * static_cast<float>(routeMetresPerUnit(from.y));
+    // Nor is one that leads away from the destination (the position is already past that part of the old route)
+    bool spliced = false;
+    bool changed = false;
+    if (piece.lengthM <= 3.0f * straight + 500.0f && rejoinLeadsOn(from, join, destination, piece.lengthM)) {
+        lock();
+        changed = changes.load() != generation;
+        spliced = !changed && spliceRoute(piece, routes[current], target, next);
+        rejoinGeneration = generation;
+        unlock();
+    }
+    if (changed) {
+        // The route was cleared or replaced meanwhile: nothing is restored, and no search to the old goal follows
+        logInfo("Route rejoin: the route changed during the search, dropped");
+        next.clear();
+        rejoinCancelled = true;
+        return false;
+    }
+    if (!spliced) {
+        logInfo("Route rejoin: %.0f m for %.0f m in a straight line, or away from the destination: searching to the destination",
+            piece.lengthM, straight);
+        next.clear();
+        return false;
+    }
+    stats = pieceStats;
+    logInfo("Route rejoin: %.0f m back to the route, %.0f m in all, %u ms (settled %u, tiles %u)", piece.lengthM, next.lengthM, pieceStats.totalMs,
+        pieceStats.settled, pieceStats.tilesRead);
+    return true;
+}
+
 bool Navigator::bench(const char* pairsPath, RouteProfile profile) {
     if (task == nullptr || currentState == State::Searching) {
         return false;
@@ -216,6 +323,17 @@ bool Navigator::bench(const char* pairsPath, RouteProfile profile) {
     return true;
 }
 
+bool Navigator::requestTrack(const char* gpxPath) {
+    if (task == nullptr || currentState == State::Searching) {
+        return false;
+    }
+    snprintf(benchPath, sizeof(benchPath), "%s", gpxPath);
+    currentState = State::Searching;
+    job = Job::Track;
+    xSemaphoreGive(wake);
+    return true;
+}
+
 RouteResult Navigator::takeResult() {
     const RouteResult value = result;
     if (currentState == State::Done || currentState == State::Failed) {
@@ -254,6 +372,8 @@ void Navigator::loop() {
             runSides();
         } else if (next == Job::Bench) {
             runBench();
+        } else if (next == Job::Track) {
+            runTrack();
         }
     }
     xSemaphoreGive(stopped);
@@ -286,7 +406,7 @@ void Navigator::giveMemory() {
 }
 
 void Navigator::runRoute() {
-    CardSource source(*io, *store);
+    CardSource source(*io, *store, *worker);
     // Memory may be short during a download: waits up to 10 s for it
     bool memory = false;
     for (int attempt = 0; attempt < 10 && !(memory = takeMemory()); attempt++) {
@@ -298,7 +418,12 @@ void Navigator::runRoute() {
         return;
     }
     Route& next = routes[1 - current];
-    const RouteResult found = search.find(source, requestFrom[0], requestFrom[1], requestTo[0], requestTo[1], requestProfile, next, &stats);
+    rejoinCancelled = false;
+    rejoined = requestProgress >= 0.0f && runRejoin(source, next);
+    // A stopped search (the app closes, another mode was chosen) is not followed by the long one
+    const RouteResult found = rejoined ? RouteResult::Found
+        : (rejoinCancelled ? RouteResult::Cancelled
+            : search.find(source, requestFrom[0], requestFrom[1], requestTo[0], requestTo[1], requestProfile, next, &stats));
     giveMemory();
     logInfo("Route %s: %s, %.0f m, %.0f s, %u points, %u steps; %u ms (reading %u ms), settled %u, tiles %u (%u missing), peak %u KB%s",
         routeProfileName(requestProfile), routeResultText(found), next.lengthM, next.seconds, static_cast<unsigned>(next.points.size()),
@@ -307,6 +432,19 @@ void Navigator::runRoute() {
     result = found;
     if (found == RouteResult::Found) {
         lock();
+        if (rejoined && changes.load() != rejoinGeneration) {
+            // "Clear route" came between the splice and here: the cleared route is not brought back
+            unlock();
+            next.clear();
+            result = RouteResult::Cancelled;
+            currentState = State::Failed;
+            return;
+        }
+        if (rejoined) {
+            // The side roads of the old route go on being used: most of the route is the same, and working them out
+            // again reads every tile along it (5 to 6 s of card time after each new route, 14 Nov)
+            next.sides.swap(routes[current].sides);
+        }
         current = 1 - current;
         routeReady = true;
         changes++;
@@ -315,9 +453,90 @@ void Navigator::runRoute() {
         routes[1 - current].clear();
         currentState = State::Done;
         // The roads beside the route, for the follower's edge rule: after the route is shown, not before
-        runSides();
+        if (!rejoined) {
+            runSides();
+        }
+    } else {
+        next.clear();
+        currentState = State::Failed;
+    }
+}
+
+void Navigator::runTrack() {
+    // The file is read in chunks, with the card free for the map in between, and never held whole
+    constexpr size_t CHUNK = 8192;
+    struct Chunk {
+        const char* path;
+        long offset;
+        char* buffer;
+        size_t count;
+        long fileSize;
+    };
+    auto* buffer = static_cast<char*>(largeAlloc(CHUNK));
+    void* memory = largeAlloc(sizeof(TrackRouteBuilder));
+    auto* builder = memory != nullptr ? new (memory) TrackRouteBuilder() : nullptr;
+    Route& next = routes[1 - current];
+    bool ok = buffer != nullptr && builder != nullptr;
+    bool read = false;
+    const uint32_t started = nowMs();
+    if (ok) {
+        GpxReader reader(*builder);
+        Chunk chunk { benchPath, 0, buffer, 0, -1 };
+        auto readChunk = [&]() {
+            FILE* file = fopen(chunk.path, "rb");
+            if (file == nullptr) {
+                return false;
+            }
+            bool fine = true;
+            if (chunk.fileSize < 0) {
+                fine = fseek(file, 0, SEEK_END) == 0;
+                chunk.fileSize = fine ? ftell(file) : -1;
+            }
+            fine = fine && fseek(file, chunk.offset, SEEK_SET) == 0;
+            chunk.count = fine ? fread(chunk.buffer, 1, CHUNK, file) : 0;
+            fclose(file);
+            return fine;
+        };
+        bool fed = true;
+        read = runOnCard(*io, readChunk, IoPriority::Background);
+        while (read && chunk.count > 0 && job.load() != Job::Quit) {
+            if (!reader.feed(buffer, chunk.count)) {
+                fed = false;
+                break;
+            }
+            chunk.offset += static_cast<long>(chunk.count);
+            if (chunk.offset >= chunk.fileSize) {
+                break;
+            }
+            read = runOnCard(*io, readChunk, IoPriority::Background);
+            vTaskDelay(1);
+        }
+        // A damaged or unfinished file (no closing tags), or the app closing (stop()), gives no route: the old one
+        // stays, and nothing half-read is saved
+        const bool finished = reader.finish();
+        const bool quit = job.load() == Job::Quit;
+        ok = read && fed && finished && !quit && builder->finish(next) && job.load() != Job::Quit;
+        logInfo("Route from the GPX file %s: %s, %u points read, %u kept, %.0f m, %u ms", benchPath, ok ? "made" : "none",
+            static_cast<unsigned>(builder->pointsRead()), static_cast<unsigned>(next.points.size()), next.lengthM, nowMs() - started);
+    }
+    if (builder != nullptr) {
+        builder->~TrackRouteBuilder();
+    }
+    largeFree(memory);
+    largeFree(buffer);
+    if (ok) {
+        result = RouteResult::Found;
+        lock();
+        current = 1 - current;
+        routeReady = true;
+        changes++;
+        unlock();
+        saveRoute(routes[current]);
+        routes[1 - current].clear();
+        currentState = State::Done;
     } else {
         next.clear();
+        result = buffer == nullptr || builder == nullptr ? RouteResult::NoMemory : RouteResult::NoTrack;
         currentState = State::Failed;
     }
 }
@@ -341,7 +560,7 @@ void Navigator::runSides() {
     if (points.size() < 2) {
         return;
     }
-    CardSource source(*io, *store);
+    CardSource source(*io, *store, *worker);
     GrowArray<RouteSide> sides;
     const uint32_t started = nowMs();
     const bool complete = search.addSides(source, points, sides);
@@ -370,7 +589,7 @@ void Navigator::runBench() {
         currentState = State::Failed;
         return;
     }
-    CardSource source(*io, *store);
+    CardSource source(*io, *store, *worker);
     Route& scratch = routes[1 - current];
     const int firstProfile = requestProfile == RouteProfile::Count ? 0 : static_cast<int>(requestProfile);
     const int lastProfile = requestProfile == RouteProfile::Count ? 2 : firstProfile;
@@ -437,7 +656,8 @@ bool Navigator::saveRoute(const Route& route) {
         out.push(static_cast<uint8_t>(c));
     }
     putU16(out, ROUTE_FILE_VERSION);
-    putU16(out, static_cast<uint16_t>(route.profile));
+    // The top bit: a route made from a GPX track
+    putU16(out, static_cast<uint16_t>(static_cast<uint16_t>(route.profile) | (route.track ? 0x8000u : 0u)));
     putU32(out, static_cast<uint32_t>(route.from.x));
     putU32(out, static_cast<uint32_t>(route.from.y));
     putU32(out, static_cast<uint32_t>(route.to.x));
@@ -482,6 +702,7 @@ bool Navigator::loadRoute() {
     Route& route = routes[current];
     route.clear();
     route.profile = static_cast<RouteProfile>(std::min<int>(data[6], static_cast<int>(RouteProfile::Car)));
+    route.track = (data[7] & 0x80) != 0;
     route.from = { static_cast<int32_t>(readU32(data + 8)), static_cast<int32_t>(readU32(data + 12)) };
     route.to = { static_cast<int32_t>(readU32(data + 16)), static_cast<int32_t>(readU32(data + 20)) };
     route.seconds = static_cast<float>(readU32(data + 24));
diff --git a/Apps/Maps/main/Source/app/Navigator.h b/Apps/Maps/main/Source/app/Navigator.h
index 86638f9..79d0159 100644
--- a/Apps/Maps/main/Source/app/Navigator.h
+++ b/Apps/Maps/main/Source/app/Navigator.h
@@ -35,8 +35,21 @@ class Navigator {
 
     /** Starts a search; false while one runs. The result replaces the current route only when one is found. */
     bool request(double fromLat, double fromLon, double toLat, double toLon, RouteProfile profile);
+    /**
+     * A new route for a position that left the current one at progressM along it (0.6.0): first a short search back
+     * to the current route a little ahead, keeping the rest of it; when that gives nothing sensible, the search to
+     * the destination as request() does. False while a search runs.
+     */
+    bool requestRejoin(double fromLat, double fromLon, double toLat, double toLon, RouteProfile profile, float progressM);
+    /** Whether the last route came from a rejoin (the rest of the old route kept), for the log. */
+    bool lastWasRejoin() const { return rejoined; }
     /** Runs the pairs of a file (host/routing/export_pairs.py) with one profile or all (Count), logging each, for measurements. */
     bool bench(const char* pairsPath, RouteProfile profile);
+    /**
+     * Makes the route from the first track or route of a GPX file (0.6.0) instead of searching one; false while a
+     * search runs. The result comes like a search's (state(), takeResult()).
+     */
+    bool requestTrack(const char* gpxPath);
     void cancel() { search.cancel(); }
 
     State state() const { return currentState.load(); }
@@ -54,14 +67,20 @@ class Navigator {
     /** Drops the route and deletes route.bin. */
     void clearRoute();
 
+    /** For the stack measurements of the debug script. */
+    TaskHandle_t taskHandle() const { return task; }
+
 private:
-    enum class Job : uint8_t { None, Route, Bench, Sides, Quit };
+    enum class Job : uint8_t { None, Route, Bench, Sides, Track, Quit };
 
     static void taskMain(void* context);
     void loop();
     void runRoute();
+    /** The short search back to the current route; true when `next` holds the spliced route. */
+    bool runRejoin(GraphSource& source, Route& next);
     void runBench();
     void runSides();
+    void runTrack();
     bool takeMemory();
     void giveMemory();
     bool saveRoute(const Route& route);
@@ -90,6 +109,12 @@ class Navigator {
     RouteStats stats {};
     double requestFrom[2] {};
     double requestTo[2] {};
+    /** Progress along the current route for a rejoin; negative: a plain search. */
+    float requestProgress = -1.0f;
+    bool rejoined = false;
+    bool rejoinCancelled = false;
+    /** The route change count the rejoin was spliced against: the splice is installed only if it still holds. */
+    uint32_t rejoinGeneration = 0;
     RouteProfile requestProfile = RouteProfile::Walk;
 };
 
diff --git a/Apps/Maps/main/Source/app/SearchIndexJob.cpp b/Apps/Maps/main/Source/app/SearchIndexJob.cpp
index 2c82181..948042d 100644
--- a/Apps/Maps/main/Source/app/SearchIndexJob.cpp
+++ b/Apps/Maps/main/Source/app/SearchIndexJob.cpp
@@ -3,6 +3,7 @@
 
 #include "../mvt/MvtDecoder.h"
 #include "../platform/Platform.h"
+#include "../platform/SafeFile.h"
 #include "../route/GrowArray.h"
 #include "../search/SearchStream.h"
 #include "../tiles/RegionMeta.h"
@@ -34,7 +35,7 @@ constexpr uint32_t SORT_BUFFER = 64 * 1024;
 /** Files the build keeps open at once: the card's FAT mount allows four for the whole system. */
 constexpr int REAL_FILES = 2;
 /** The stamp's format: change it to rebuild every index (e.g. after a change of the builder's output). */
-constexpr char STAMP_VERSION[] = "sidx1";
+constexpr char STAMP_VERSION[] = "sidx2";   // sidx2 (0.6.0): streets named only by name_int are in
 
 template <typename Function>
 bool onCard(IoTask& io, Function& function) {
@@ -443,7 +444,7 @@ bool keepGoingHook(const StreamProgress& progress, void* context) {
         // The FAT mount allows 4 open files for the whole system: the download needs them
         hook->files->suspend();
     }
-    return hook->job->keepGoing(static_cast<int32_t>(progress.done), static_cast<int32_t>(progress.total));
+    return hook->job->keepGoing(static_cast<int32_t>(progress.done), static_cast<int32_t>(progress.total), progress.phase);
 }
 
 /** The task suspends itself when its work is over: it must not run any more when it is deleted. */
@@ -460,6 +461,13 @@ void waitUntilSuspended(TaskHandle_t task) {
 
 } // namespace
 
+Translit translitForRegion(const char* region) {
+    if (strcmp(region, "kyiv") == 0) {
+        return Translit::Ukrainian;
+    }
+    return strcmp(region, "belgrade") == 0 ? Translit::Serbian : Translit::Russian;
+}
+
 SearchIndexJob::~SearchIndexJob() {
     stop();
 }
@@ -479,6 +487,7 @@ bool SearchIndexJob::start(IoTask& ioTask, const char* rootPath, const char* fir
     progressDone = 0;
     progressTotal = 0;
     lowestFree = static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_SPIRAM));
+    buildLowestFree = lowestFree;
     currentState = State::Busy;
     if (xTaskCreatePinnedToCoreWithCaps(taskMain, "maps-sidx", TASK_STACK, this, TASK_PRIORITY, &task, tskNO_AFFINITY, MALLOC_CAP_SPIRAM) !=
         pdPASS) {
@@ -521,11 +530,17 @@ void SearchIndexJob::taskMain(void* context) {
     vTaskSuspend(nullptr);
 }
 
-bool SearchIndexJob::keepGoing(int32_t done, int32_t total) {
+bool SearchIndexJob::keepGoing(int32_t done, int32_t total, uint8_t phase) {
     progressDone = done;
     progressTotal = total;
     const auto free = static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_SPIRAM));
     lowestFree = std::min(lowestFree, free);
+    buildLowestFree = std::min(buildLowestFree, free);
+    if (phase < MEMORY_PHASES) {
+        const auto largest = static_cast<uint32_t>(heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM));
+        phaseFree[phase] = std::min(phaseFree[phase], free);
+        phaseLargest[phase] = std::min(phaseLargest[phase], largest);
+    }
     while (paused.load() && !stopping.load()) {
         vTaskDelay(pdMS_TO_TICKS(250));
     }
@@ -663,6 +678,12 @@ bool SearchIndexJob::buildRegion(const char* region) {
         return true;
     };
     onCard(*io, makeFolders);
+    // The old stamp goes before any block is rewritten: a build that fails half way must not leave new blocks under a matching stamp
+    auto removeStamp = [&]() {
+        ::remove(stampPath);
+        return true;
+    };
+    onCard(*io, removeStamp);
     // Memory for the build: decoder, a tile buffer, the builder (freed at the end)
     void* decoderMemory = largeAlloc(sizeof(MvtDecoder));
     auto* buffer = static_cast<uint8_t*>(largeAlloc(TILE_CHUNK));
@@ -681,8 +702,7 @@ bool SearchIndexJob::buildRegion(const char* region) {
     options.sortBufferBytes = SORT_BUFFER;
     options.keepGoing = keepGoingHook;
     options.context = &hook;
-    const char* profile = strcmp(region, "kyiv") == 0 ? "uk" : (strcmp(region, "belgrade") == 0 ? "sr" : "ru");
-    options.config.profile = profile[0] == 'u' ? Translit::Ukrainian : (profile[0] == 's' ? Translit::Serbian : Translit::Russian);
+    options.config.profile = translitForRegion(region);
     // One block at a time (all tiles when the region is small)
     GrowArray<StreamTile> blockTiles;
     IndexFiles made;
@@ -723,6 +743,10 @@ bool SearchIndexJob::buildRegion(const char* region) {
             CardTileSource source(*io, regionPath, buffer, owned);
             const uint32_t freeBefore = static_cast<uint32_t>(heap_caps_get_free_size(MALLOC_CAP_SPIRAM));
             lowestFree = freeBefore;
+            for (int i = 0; i < MEMORY_PHASES; i++) {
+                phaseFree[i] = UINT32_MAX;
+                phaseLargest[i] = UINT32_MAX;
+            }
             const uint32_t started = nowMs();
             ok = builder->build(files, scratch, blockTiles.begin(), static_cast<uint32_t>(blockTiles.size()), source, *decoder, outPath, temporary,
                                 options);
@@ -741,6 +765,21 @@ bool SearchIndexJob::buildRegion(const char* region) {
             report("Search index %s%s%s: %u tiles in %u ms, %u bytes; PSRAM %u KB free before, %u KB lowest", region, blocks ? " " : "",
                    blockName, static_cast<unsigned>(blockTiles.size()), static_cast<unsigned>(nowMs() - started),
                    static_cast<unsigned>(s.index.totalBytes), static_cast<unsigned>(freeBefore / 1024), static_cast<unsigned>(lowestFree / 1024));
+            {
+                // Lowest free PSRAM / smallest largest block per step, in KB (0/0: the step never reported)
+                char line[sizeof(reports[0])];
+                int at = snprintf(line, sizeof(line), "Search index KB free/largest:");
+                static const char* const NAMES[MEMORY_PHASES] = { "tile", "pnt", "hse", "clu", "mat", "adr",
+                    "rec", "grp", "grec", "key", "file" };
+                for (int i = 0; i < MEMORY_PHASES && at < static_cast<int>(sizeof(line)) - 1; i++) {
+                    if (phaseFree[i] != UINT32_MAX) {
+                        at += snprintf(line + at, sizeof(line) - static_cast<size_t>(at), " %s %u/%u", NAMES[i],
+                            static_cast<unsigned>(phaseFree[i] / 1024), static_cast<unsigned>(phaseLargest[i] / 1024));
+                    }
+                }
+                report("%s", line);
+                logMemory("after an index block");
+            }
             report("Search index phases ms: tiles %u points %u clusters %u matching %u addresses %u groups %u keys %u file %u", s.phaseMs[0],
                    s.phaseMs[1], s.phaseMs[2], s.phaseMs[3], s.phaseMs[4], s.phaseMs[5], s.phaseMs[6], s.phaseMs[7]);
             report("Search index slowest tile %d/%d %u ms, matching %d/%d %u ms; scratch %u KB, sort %u KB, tables %u KB, matcher %u KB",
@@ -786,10 +825,18 @@ bool SearchIndexJob::buildRegion(const char* region) {
                 removeFolder(blockFolder);
             }
         }
-        FILE* file = fopen(stampPath, "wb");
+        // Through a temporary file: a half-written stamp must not match
+        char stampTemporary[PATH_MAX_LENGTH];
+        snprintf(stampTemporary, sizeof(stampTemporary), "%s/stamp.tmp", regionPath);
+        FILE* file = fopen(stampTemporary, "wb");
         if (file != nullptr) {
-            fprintf(file, "%s\n", stamp);
-            fclose(file);
+            const bool written = fprintf(file, "%s\n", stamp) > 0;
+            const bool closed = fclose(file) == 0;
+            if (written && closed) {
+                replaceFile(stampTemporary, stampPath);
+            } else {
+                ::remove(stampTemporary);
+            }
         }
         return true;
     };
diff --git a/Apps/Maps/main/Source/app/SearchIndexJob.h b/Apps/Maps/main/Source/app/SearchIndexJob.h
index 8e9ff71..363da76 100644
--- a/Apps/Maps/main/Source/app/SearchIndexJob.h
+++ b/Apps/Maps/main/Source/app/SearchIndexJob.h
@@ -3,6 +3,7 @@
 
 #include "IoTask.h"
 
+#include "../search/TextFold.h"
 #include "../tiles/TilePaths.h"
 
 #include <freertos/FreeRTOS.h>
@@ -13,6 +14,9 @@
 
 namespace maps {
 
+/** The transliteration profile of a region's names: Ukrainian for kyiv, Serbian for belgrade, else Russian. Used to build and to read an index. */
+Translit translitForRegion(const char* region);
+
 /**
  * Builds the offline search indexes in idle time (M6): for every region on the card whose index is missing or older
  * than its tiles (maps/<region>/search.inf holds the meta.json version, date and tile count it was built from), the
@@ -53,12 +57,15 @@ class SearchIndexJob {
     /** One report line at a time for the log (measurements), nullptr when there is none; the line stays until the next call. */
     const char* nextReport();
     /** The lowest free PSRAM seen during the build, in bytes. */
-    uint32_t lowestFreePsram() const { return lowestFree; }
+    uint32_t lowestFreePsram() const { return buildLowestFree; }
 
     /** Called by the builder between steps: waits while paused, false when stopping. */
-    bool keepGoing(int32_t done, int32_t total);
+    bool keepGoing(int32_t done, int32_t total, uint8_t phase = 0);
     void report(const char* format, ...);
 
+    /** For the stack measurements of the debug script. */
+    TaskHandle_t taskHandle() const { return task; }
+
 private:
     static void taskMain(void* context);
     void run();
@@ -77,6 +84,12 @@ class SearchIndexJob {
     bool forceBuild = false;
     int written = 0;
     uint32_t lowestFree = 0;
+    /** The lowest of all blocks of this build (lowestFree starts again with each block). */
+    uint32_t buildLowestFree = 0;
+    /** Per build step of the block being built: lowest free PSRAM and smallest largest free block, in bytes. */
+    static constexpr int MEMORY_PHASES = 11;
+    uint32_t phaseFree[MEMORY_PHASES] = {};
+    uint32_t phaseLargest[MEMORY_PHASES] = {};
     /** Report lines: written by the task, read by the map loop (a small ring, guarded by the counters). */
     static constexpr int REPORT_LINES = 24;
     char reports[REPORT_LINES][200] = {};
diff --git a/Apps/Maps/main/Source/app/SearchTask.h b/Apps/Maps/main/Source/app/SearchTask.h
index 733a3f7..c9ebd4d 100644
--- a/Apps/Maps/main/Source/app/SearchTask.h
+++ b/Apps/Maps/main/Source/app/SearchTask.h
@@ -26,6 +26,9 @@ class SearchTask {
     /** The least stack the task has had left, in bytes (for the log). */
     uint32_t stackLeft() const { return task != nullptr ? static_cast<uint32_t>(uxTaskGetStackHighWaterMark(task)) : 0; }
 
+    /** For the stack measurements of the debug script. */
+    TaskHandle_t taskHandle() const { return task; }
+
 private:
     static void taskMain(void* context);
 
diff --git a/Apps/Maps/main/Source/app/TileWorker.cpp b/Apps/Maps/main/Source/app/TileWorker.cpp
index c2881a3..25ad2c4 100644
--- a/Apps/Maps/main/Source/app/TileWorker.cpp
+++ b/Apps/Maps/main/Source/app/TileWorker.cpp
@@ -698,14 +698,44 @@ bool TileWorker::loadLabels(Lane& lane) {
     return true;
 }
 
+bool TileWorker::prepareForRoute(const TileKey& tile, int region) {
+    lock();
+    bool failed = false;
+    for (int i = 0; i < failedConversionCount; i++) {
+        failed = failed || failedConversions[i] == tile;
+    }
+    const bool queued = !failed && queueConversion(tile, region, true);
+    if (queued) {
+        routeWanted = true;
+    }
+    unlock();
+    return queued;
+}
+
+bool TileWorker::isPreparingTile(const TileKey& tile) {
+    lock();
+    bool preparing = false;
+    for (int i = 0; i < conversionCount; i++) {
+        preparing = preparing || conversions[i].tile == tile;
+    }
+    for (int i = 0; i < laneCount; i++) {
+        preparing = preparing || (lanes[i].converting && lanes[i].convertingTile == tile);
+    }
+    unlock();
+    return preparing;
+}
+
 bool TileWorker::convertOne(Lane& lane) {
-    if (routing) {
+    // A route search has the card, the memory and the cores, except for a tile it waits for itself
+    if (routing && !routeWanted) {
         return false;
     }
     // While a download runs (it leaves PSRAM fragmented), only the tiles on screen are prepared, so their POIs and house
     // numbers show at once instead of after the download; the others wait until it is over. The download keeps memory
     // to spare: the tile cache gives up slots that are not on screen for it (they come back after the download).
-    if (conversionsPaused) {
+    // The same while a search index is built: both are idle work, and the build's peak with a conversion's buffers
+    // (and the labels and tiles around the screen) on top left 67 KB less PSRAM free (657 KB, 13 Nov)
+    if (conversionsPaused || indexing) {
         lock();
         const bool onScreen = conversionCount > 0 && conversions[0].urgent;
         unlock();
@@ -736,7 +766,7 @@ bool TileWorker::convertOne(Lane& lane) {
         return false;
     }
     // Tiles not on screen wait until the map was left alone for a while: they are queued now, prepared later
-    const bool settled = now - idleSince.load() >= pdMS_TO_TICKS(BACKGROUND_PREPARE_MS);
+    const bool settled = !routing && now - idleSince.load() >= pdMS_TO_TICKS(BACKGROUND_PREPARE_MS);
     lock();
     Conversion job {};
     bool found = false;
@@ -1010,6 +1040,10 @@ void TileWorker::unlockIndex(void* context) {
 }
 
 void TileWorker::saveCacheIndex() {
+    // One save at a time: both lanes fill the same indexBytes, and the card job reads it outside the lock
+    if (indexSaving.exchange(true)) {
+        return;   // the index stays dirty where it changed since; the next save writes it
+    }
     lock();
     const bool dirty = cacheIndex.isDirty();
     if (dirty) {
@@ -1022,6 +1056,7 @@ void TileWorker::saveCacheIndex() {
         IndexFileJob job { root, styleId, nullptr, &indexBytes };
         io->run(IoPriority::Background, writeIndexJob, &job);
     }
+    indexSaving = false;
 }
 
 bool TileWorker::tidyCache() {
@@ -1144,6 +1179,8 @@ bool TileWorker::writeOne(Lane& lane) {
             pendingWrites[pendingWriteCount++] = tile;
         }
         unlock();
+        // A card that fails every write (full, removed) must not keep the lane and the I/O task spinning
+        vTaskDelay(pdMS_TO_TICKS(250));
     }
     return true;
 }
@@ -1406,7 +1443,7 @@ void TileWorker::loop(Lane& lane) {
             visible = false;
             // Around the screen and other idle work only after a while without input
             // Not during a route search: the user waits for it, and the cache has lent it most of its slots
-            if (!idle || routing || !claimNext(lane, false, tile, pixels)) {
+            if (!idle || routing || indexing || !claimNext(lane, false, tile, pixels)) {
                 if (!idle || (!convertOne(lane) && !tidyCache())) {
                     vTaskDelay(pdMS_TO_TICKS(IDLE_WAIT_MS));
                 }
diff --git a/Apps/Maps/main/Source/app/TileWorker.h b/Apps/Maps/main/Source/app/TileWorker.h
index 0d62490..5e0d140 100644
--- a/Apps/Maps/main/Source/app/TileWorker.h
+++ b/Apps/Maps/main/Source/app/TileWorker.h
@@ -110,7 +110,21 @@ class TileWorker {
      */
     void setConversionsPaused(bool paused);
     /** While a route search runs no tiles are prepared and none around the screen drawn: it needs the card, the memory and the cores. */
-    void setRouting(bool value) { routing = value; }
+    void setRouting(bool value) {
+        routing = value;
+        if (!value) {
+            routeWanted = false;
+        }
+    }
+    /**
+     * The route search needs the graph of a tile that is on the card but not prepared yet (a new region, or the z10
+     * tiles after an update): it is prepared now, before everything else and although a search runs. False when it
+     * cannot be (it failed before). The search waits with isPreparingTile().
+     */
+    bool prepareForRoute(const TileKey& tile, int region);
+    bool isPreparingTile(const TileKey& tile);
+    /** While a search index is built only tiles on screen are prepared and none around the screen drawn: the build has the idle time. */
+    void setIndexing(bool value) { indexing = value; }
     /** Whether rendered tiles are read from and written to the SD card cache. */
     void setSdCache(bool enabled) { sdCache = enabled; }
     /** Idle: no input for a while, so prefetch, conversions and cache tidying may run. */
@@ -293,6 +307,9 @@ class TileWorker {
     std::atomic<bool> deflatePrepared = true;
     std::atomic<bool> conversionsPaused = false;
     std::atomic<bool> routing = false;
+    /** The running search asked for a tile (prepareForRoute): urgent tiles are prepared although it runs. */
+    std::atomic<bool> routeWanted = false;
+    std::atomic<bool> indexing = false;
     bool magnifiedOutdated = false;
     std::atomic<bool> sdCache = true;
     std::atomic<bool> idle = false;
@@ -304,6 +321,8 @@ class TileWorker {
     CacheWalker cacheWalker;
     bool walking = false;
     int writesSinceSave = 0;
+    /** A lane is writing the cache index (both fill the same buffer). */
+    std::atomic<bool> indexSaving { false };
     ByteWriter indexBytes;
 };
 
diff --git a/Apps/Maps/main/Source/app/TrackRecorder.cpp b/Apps/Maps/main/Source/app/TrackRecorder.cpp
index 5fe7cdb..5dcf1a0 100644
--- a/Apps/Maps/main/Source/app/TrackRecorder.cpp
+++ b/Apps/Maps/main/Source/app/TrackRecorder.cpp
@@ -49,6 +49,22 @@ void TrackRecorder::closeUnfinished(IoTask& io, const char* root) {
         listDirectory(folder, [](const char* fileName, bool isDirectory, void* data) {
             auto* context = static_cast<Context*>(data);
             const size_t length = strlen(fileName);
+            if (!isDirectory && length > 8 && strcmp(fileName + length - 8, ".gpx.tmp") == 0) {
+                // Left by a power cut while a track was closed: the copy is whole when the track itself is gone (it is
+                // removed only after the copy), else it is a leftover
+                char temporary[PATH_MAX_LENGTH + 8];
+                char original[PATH_MAX_LENGTH + 8];
+                snprintf(temporary, sizeof(temporary), "%s/%s", context->folder, fileName);
+                snprintf(original, sizeof(original), "%s/%.*s", context->folder, static_cast<int>(length - 4), fileName);
+                FILE* exists = fopen(original, "rb");
+                if (exists != nullptr) {
+                    fclose(exists);
+                    remove(temporary);
+                } else if (rename(temporary, original) == 0) {
+                    context->closed++;
+                }
+                return true;
+            }
             if (isDirectory || length < 5 || strcmp(fileName + length - 4, ".gpx") != 0) {
                 return true;
             }
@@ -61,8 +77,9 @@ void TrackRecorder::closeUnfinished(IoTask& io, const char* root) {
             const bool closed = isClosed(track);
             // A crash can only have cut a line in the middle: the last whole point is kept, then the end tags
             long keep = 0;
+            long size = 0;
             if (!closed && fseek(track, 0, SEEK_END) == 0) {
-                const long size = ftell(track);
+                size = ftell(track);
                 const long window = size < 320 ? size : 320;
                 char last[321];
                 if (fseek(track, size - window, SEEK_SET) == 0 && fread(last, 1, static_cast<size_t>(window), track) == static_cast<size_t>(window)) {
@@ -86,6 +103,17 @@ void TrackRecorder::closeUnfinished(IoTask& io, const char* root) {
             if (closed || keep <= 0) {
                 return true;
             }
+            if (keep == size) {
+                // Nothing cut: the end tags are added in place, the track is never away from the card
+                FILE* target = fopen(file, "ab");
+                if (target != nullptr) {
+                    const bool added = fputs(TRACK_END, target) >= 0;
+                    if (fclose(target) == 0 && added) {
+                        context->closed++;
+                    }
+                }
+                return true;
+            }
             // Copied up to the last whole point through a .tmp file, then the end tags
             char temporary[PATH_MAX_LENGTH + 8];
             snprintf(temporary, sizeof(temporary), "%s.tmp", file);
@@ -272,22 +300,28 @@ bool TrackRecorder::flush(IoTask& io, const char* closing) {
     if (pendingLength == 0 && closing == nullptr) {
         return true;
     }
+    size_t wrote = 0;
     auto append = [&] {
         FILE* file = fopen(path, "ab");
         if (file == nullptr) {
             return false;
         }
-        bool ok = pendingLength == 0 || fwrite(pending, 1, pendingLength, file) == pendingLength;
+        wrote = pendingLength == 0 ? 0 : fwrite(pending, 1, pendingLength, file);
+        bool ok = wrote == pendingLength;
         if (ok && closing != nullptr) {
             ok = fputs(closing, file) >= 0;
         }
-        fclose(file);
-        return ok;
+        return fclose(file) == 0 && ok;
     };
     const bool ok = runOnCard(io, append, IoPriority::Background);
-    if (ok) {
+    // What reached the file leaves the buffer, also after a short write: the rest follows it next time, nothing twice
+    if (wrote >= pendingLength) {
         pendingLength = 0;
-    } else {
+    } else if (wrote > 0) {
+        memmove(pending, pending + wrote, pendingLength - wrote);
+        pendingLength -= wrote;
+    }
+    if (!ok) {
         logError("Could not write to %s", path);
     }
     return ok;
diff --git a/Apps/Maps/main/Source/gpx/GpxReader.cpp b/Apps/Maps/main/Source/gpx/GpxReader.cpp
index 3863bcb..f569e06 100644
--- a/Apps/Maps/main/Source/gpx/GpxReader.cpp
+++ b/Apps/Maps/main/Source/gpx/GpxReader.cpp
@@ -35,6 +35,10 @@ bool parseDouble(const char* text, double& out) {
     if (*end != '\0') {
         return false;
     }
+    // strtod also reads "inf" and "nan"; neither is a number a file can mean here
+    if (!std::isfinite(value)) {
+        return false;
+    }
     out = value;
     return true;
 }
@@ -135,6 +139,27 @@ bool parseTimeText(const char* text, int64_t& out) {
     return true;
 }
 
+// Length of text without a UTF-8 sequence that was cut off at the end
+size_t completeUtf8Length(const char* text, size_t length) {
+    size_t start = length;
+    while (start > 0 && length - start < 3 && (static_cast<unsigned char>(text[start - 1]) & 0xC0) == 0x80) {
+        start--;
+    }
+    if (start == 0) {
+        return length;
+    }
+    const unsigned char lead = static_cast<unsigned char>(text[start - 1]);
+    size_t need = 1;
+    if (lead >= 0xF0) {
+        need = 4;
+    } else if (lead >= 0xE0) {
+        need = 3;
+    } else if (lead >= 0xC0) {
+        need = 2;
+    }
+    return length - (start - 1) < need ? start - 1 : length;
+}
+
 void appendCodePoint(char* out, size_t size, size_t& used, uint32_t code) {
     if (code < 0x80) {
         if (used + 1 < size) {
@@ -236,6 +261,8 @@ void decodeEntities(const char* in, char* out, size_t size) {
         }
         index++;
     }
+    // Where the output was full a multi-byte character can be cut; leave it out whole
+    used = completeUtf8Length(out, used);
     out[used] = '\0';
 }
 
@@ -590,7 +617,7 @@ void GpxReader::finishStartTag(bool selfClosing) {
         rootSeen_ = true;
     }
     if (depth_ >= kMaxDepth) {
-        fail("The file is incomplete");
+        fail("The file is nested too deep");
         return;
     }
     const Role parent = depth_ > 0 ? stack_[depth_ - 1].role : Role::None;
@@ -772,6 +799,8 @@ void GpxReader::decodeText(char* out, size_t size) {
     while (end > begin && isSpace(text_[end - 1])) {
         end--;
     }
+    // The text buffer is short, so a long text can end in the middle of a character
+    end = begin + completeUtf8Length(text_ + begin, end - begin);
     text_[end] = '\0';
     decodeEntities(text_ + begin, out, size);
 }
diff --git a/Apps/Maps/main/Source/gpx/GpxWriter.cpp b/Apps/Maps/main/Source/gpx/GpxWriter.cpp
index 007302e..ca45a88 100644
--- a/Apps/Maps/main/Source/gpx/GpxWriter.cpp
+++ b/Apps/Maps/main/Source/gpx/GpxWriter.cpp
@@ -87,9 +87,12 @@ void addPointBody(TextBuilder& builder, const GpxPoint& point, const char* tag)
         formatGpxTime(point.time, time, sizeof(time));
         builder.addf("<time>%s</time>", time);
     }
-    char name[256];
-    escapeXml(point.name, name, sizeof(name));
-    builder.addf("<name>%s</name>", name);
+    // A track point without a name gets no element; an empty one only costs space on every point
+    if (point.name[0] != 0) {
+        char name[256];
+        escapeXml(point.name, name, sizeof(name));
+        builder.addf("<name>%s</name>", name);
+    }
 }
 
 } // namespace
@@ -121,6 +124,11 @@ void escapeXml(const char* text, char* out, size_t size) {
     size_t used = 0;
     for (const char* p = text; *p != '\0'; p++) {
         const char* replacement = nullptr;
+        const unsigned char byte = static_cast<unsigned char>(*p);
+        // XML 1.0 has no control characters other than tab, line feed and carriage return
+        if (byte < 0x20 && byte != 0x09 && byte != 0x0A && byte != 0x0D) {
+            continue;
+        }
         switch (*p) {
         case '&':
             replacement = "&amp;";
@@ -142,6 +150,15 @@ void escapeXml(const char* text, char* out, size_t size) {
         }
         if (replacement == nullptr) {
             if (used + 1 >= size) {
+                // Cut on a character boundary: take back a UTF-8 sequence that was only started
+                if ((byte & 0xC0) == 0x80) {
+                    while (used > 0 && (static_cast<unsigned char>(out[used - 1]) & 0xC0) == 0x80) {
+                        used--;
+                    }
+                    if (used > 0) {
+                        used--;
+                    }
+                }
                 break;
             }
             out[used++] = *p;
diff --git a/Apps/Maps/main/Source/mvt/InflateReader.cpp b/Apps/Maps/main/Source/mvt/InflateReader.cpp
index f3d153f..1793f42 100644
--- a/Apps/Maps/main/Source/mvt/InflateReader.cpp
+++ b/Apps/Maps/main/Source/mvt/InflateReader.cpp
@@ -13,6 +13,11 @@ namespace {
 
 constexpr size_t WINDOW_SIZE = TINFL_LZ_DICT_SIZE;
 constexpr size_t INPUT_BUFFER_SIZE = 4096;
+/**
+ * No tile inflates to more: a damaged stream can make the decompressor give bytes without end (it reads zeros once
+ * the input is over), which hung every reader behind it (found by host/fuzz_tests).
+ */
+constexpr size_t MAX_INFLATED = 48u * 1024u * 1024u;
 
 tinfl_decompressor* asDecompressor(void* pointer) {
     return static_cast<tinfl_decompressor*>(pointer);
@@ -48,6 +53,7 @@ bool InflateReader::begin(ByteInput* source) {
     pending = nullptr;
     pendingEnd = nullptr;
     position = 0;
+    produced = 0;
     finished = false;
     error = false;
     if (decompressor == nullptr || !input->rewind() || !fillInput()) {
@@ -181,6 +187,12 @@ bool InflateReader::refill() {
             flags
         );
         inputPosition += inBytes;
+        produced += outBytes;
+        if (status < TINFL_STATUS_DONE || produced > MAX_INFLATED) {
+            // A damaged stream: what it gave with the error is not handed on
+            error = true;
+            return false;
+        }
         if (outBytes > 0) {
             pending = window + windowOffset;
             pendingEnd = pending + outBytes;
diff --git a/Apps/Maps/main/Source/mvt/InflateReader.h b/Apps/Maps/main/Source/mvt/InflateReader.h
index 4306262..bb08d42 100644
--- a/Apps/Maps/main/Source/mvt/InflateReader.h
+++ b/Apps/Maps/main/Source/mvt/InflateReader.h
@@ -65,6 +65,8 @@ class InflateReader {
     size_t position = 0;
     Format streamFormat = Format::Raw;
     bool finished = false;
+    /** Bytes inflated since begin(), to stop a stream that never ends. */
+    size_t produced = 0;
     bool error = false;
 };
 
diff --git a/Apps/Maps/main/Source/mvt/MvtDecoder.cpp b/Apps/Maps/main/Source/mvt/MvtDecoder.cpp
index f1a2c55..7424b6a 100644
--- a/Apps/Maps/main/Source/mvt/MvtDecoder.cpp
+++ b/Apps/Maps/main/Source/mvt/MvtDecoder.cpp
@@ -117,6 +117,11 @@ bool MvtDecoder::readVarint(uint64_t& value) {
     return false;
 }
 
+bool MvtDecoder::readLength(uint64_t& length) {
+    // No tile is this large: a length that would wrap a 32-bit position is a damaged file
+    return readVarint(length) && length <= MAX_FIELD_LENGTH;
+}
+
 bool MvtDecoder::skipField(uint32_t wireType) {
     uint64_t value;
     switch (wireType) {
@@ -125,7 +130,7 @@ bool MvtDecoder::skipField(uint32_t wireType) {
         case WIRE_64BIT:
             return reader.skip(8);
         case WIRE_LENGTH:
-            return readVarint(value) && reader.skip(static_cast<size_t>(value));
+            return readLength(value) && reader.skip(static_cast<size_t>(value));
         case WIRE_32BIT:
             return reader.skip(4);
         default:
@@ -149,7 +154,7 @@ bool MvtDecoder::readLayerName(size_t layerEnd, Layer& layer) {
         }
         if ((key >> 3) == 1 && (key & 7) == WIRE_LENGTH) {
             uint64_t length;
-            if (!readVarint(length)) {
+            if (!readLength(length)) {
                 return false;
             }
             char name[24];
@@ -188,7 +193,7 @@ bool MvtDecoder::scanValue(size_t valueEnd, ValueEntry& entry) {
         uint64_t number;
         if (field == 1 && wire == WIRE_LENGTH) {
             uint64_t length;
-            if (!readVarint(length)) {
+            if (!readLength(length)) {
                 return false;
             }
             char text[256];
@@ -267,7 +272,7 @@ bool MvtDecoder::scanLayer(size_t layerEnd, LayerTable& table, Layer layer) {
         const uint32_t wire = static_cast<uint32_t>(key & 7);
         if (field == 3 && wire == WIRE_LENGTH) {
             uint64_t length;
-            if (!readVarint(length)) {
+            if (!readLength(length)) {
                 return false;
             }
             char name[16];
@@ -301,6 +306,8 @@ bool MvtDecoder::scanLayer(size_t layerEnd, LayerTable& table, Layer layer) {
                     table.nameEnKey = index;
                 } else if (strcmp(name, "name:en") == 0) {
                     table.nameEnColonKey = index;
+                } else if (strcmp(name, "name_int") == 0) {
+                    table.nameIntKey = index;
                 } else if (strcmp(name, "rank") == 0) {
                     table.rankKey = index;
                 } else if (strcmp(name, "housenumber") == 0) {
@@ -312,7 +319,7 @@ bool MvtDecoder::scanLayer(size_t layerEnd, LayerTable& table, Layer layer) {
             keyIndex++;
         } else if (field == 4 && wire == WIRE_LENGTH) {
             uint64_t length;
-            if (!readVarint(length)) {
+            if (!readLength(length)) {
                 return false;
             }
             ValueEntry entry;
@@ -328,6 +335,9 @@ bool MvtDecoder::scanLayer(size_t layerEnd, LayerTable& table, Layer layer) {
             if (!readVarint(extent)) {
                 return false;
             }
+            if (extent == 0 || extent > MAX_EXTENT) {
+                return false;   // the scales divide by it
+            }
             table.extent = static_cast<int32_t>(extent);
         } else if (!skipField(wire)) {
             return false;
@@ -358,7 +368,7 @@ bool MvtDecoder::scan(ByteInput* source, bool withPoiLayers) {
         }
         if ((key >> 3) == 3 && (key & 7) == WIRE_LENGTH) {
             uint64_t length;
-            if (!readVarint(length)) {
+            if (!readLength(length)) {
                 return false;
             }
             const size_t layerEnd = reader.tell() + static_cast<size_t>(length);
@@ -434,6 +444,9 @@ void MvtDecoder::applyTag(const LayerTable& table, uint32_t key, uint32_t value,
     } else if (keyIndex == table.nameEnColonKey && entry->hasText != 0 && !info.nameEnPreferred) {
         info.nameEn = namePool + entry->textOffset;
         info.nameEnLength = entry->textLength;
+    } else if (keyIndex == table.nameIntKey && entry->hasText != 0) {
+        info.nameInt = namePool + entry->textOffset;
+        info.nameIntLength = entry->textLength;
     } else if (keyIndex == table.rankKey && isInteger) {
         info.rank = entry->rank;
     } else if (keyIndex == table.houseNumberKey && entry->hasText != 0) {
@@ -461,8 +474,12 @@ bool MvtDecoder::decodeGeometry(size_t geometryEnd, GeometrySink& sink) {
                 if (!readVarint(dx) || !readVarint(dy)) {
                     return false;
                 }
-                x += zigzag(static_cast<uint32_t>(dx));
-                y += zigzag(static_cast<uint32_t>(dy));
+                // Unsigned: a damaged file must not overflow a signed sum
+                x = static_cast<int32_t>(static_cast<uint32_t>(x) + static_cast<uint32_t>(zigzag(static_cast<uint32_t>(dx))));
+                y = static_cast<int32_t>(static_cast<uint32_t>(y) + static_cast<uint32_t>(zigzag(static_cast<uint32_t>(dy))));
+                if (command == COMMAND_LINE_TO && !ringOpen) {
+                    return false;   // a line before any MOVE_TO: its points would belong to no ring
+                }
                 if (command == COMMAND_MOVE_TO) {
                     if (ringOpen) {
                         sink.points(chunk, count);
@@ -509,7 +526,7 @@ bool MvtDecoder::decodeFeature(size_t featureEnd, Layer layer, GeometrySink& sin
         const uint32_t wire = static_cast<uint32_t>(key & 7);
         if (field == 2 && wire == WIRE_LENGTH) {
             uint64_t length;
-            if (!readVarint(length)) {
+            if (!readLength(length)) {
                 return false;
             }
             const size_t tagsEnd = reader.tell() + static_cast<size_t>(length);
@@ -529,7 +546,7 @@ bool MvtDecoder::decodeFeature(size_t featureEnd, Layer layer, GeometrySink& sin
             info.geometryType = static_cast<uint8_t>(type);
         } else if (field == 4 && wire == WIRE_LENGTH) {
             uint64_t length;
-            if (!readVarint(length)) {
+            if (!readLength(length)) {
                 return false;
             }
             const size_t geometryEnd = reader.tell() + static_cast<size_t>(length);
@@ -587,7 +604,7 @@ bool MvtDecoder::sweep(const Layer* layers, int count, GeometrySink& sink) {
             continue;
         }
         uint64_t length;
-        if (!readVarint(length)) {
+        if (!readLength(length)) {
             return false;
         }
         const size_t layerEnd = reader.tell() + static_cast<size_t>(length);
diff --git a/Apps/Maps/main/Source/mvt/MvtDecoder.h b/Apps/Maps/main/Source/mvt/MvtDecoder.h
index 6d12ed2..34cedd0 100644
--- a/Apps/Maps/main/Source/mvt/MvtDecoder.h
+++ b/Apps/Maps/main/Source/mvt/MvtDecoder.h
@@ -101,6 +101,7 @@ class MvtDecoder {
         /** "name_en" and "name:en": a layer can have both, on different features; name_en wins on a feature with both. */
         int16_t nameEnKey = -1;
         int16_t nameEnColonKey = -1;
+        int16_t nameIntKey = -1;
         int16_t rankKey = -1;
         int16_t houseNumberKey = -1;
         uint32_t valueOffset = 0;
@@ -110,6 +111,10 @@ class MvtDecoder {
 
     bool growPools();
     bool readVarint(uint64_t& value);
+    /** A varint that is the length of a field: false when it is beyond any tile (MAX_FIELD_LENGTH). */
+    bool readLength(uint64_t& length);
+    static constexpr uint64_t MAX_FIELD_LENGTH = 64u * 1024u * 1024u;
+    static constexpr uint64_t MAX_EXTENT = 65536;
     bool readLayerName(size_t layerEnd, Layer& layer);
     bool scanLayer(size_t layerEnd, LayerTable& table, Layer layer);
     bool scanValue(size_t valueEnd, ValueEntry& entry);
diff --git a/Apps/Maps/main/Source/mvt/Schema.h b/Apps/Maps/main/Source/mvt/Schema.h
index c9b19ea..f7446c4 100644
--- a/Apps/Maps/main/Source/mvt/Schema.h
+++ b/Apps/Maps/main/Source/mvt/Schema.h
@@ -73,6 +73,9 @@ struct FeatureInfo {
     /** The same from "name_en" (or "name:en"), nullptr when absent; the search uses it for places, parks, water, peaks. */
     const char* nameEn = nullptr;
     uint16_t nameEnLength = 0;
+    /** The same from "name_int" (the international name): some streets have only this one. */
+    const char* nameInt = nullptr;
+    uint16_t nameIntLength = 0;
     /** nameEn came from "name_en" (which wins over "name:en" on the same feature). */
     bool nameEnPreferred = false;
     /** "rank" as an integer, -1 when absent (place, mountain_peak and poi layers). */
diff --git a/Apps/Maps/main/Source/platform/SafeFile.h b/Apps/Maps/main/Source/platform/SafeFile.h
new file mode 100644
index 0000000..0837c6e
--- /dev/null
+++ b/Apps/Maps/main/Source/platform/SafeFile.h
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include <cstdio>
+
+namespace maps {
+
+/**
+ * Puts a finished temporary file in the place of `path`. FAT cannot rename onto an existing file, so the old one is
+ * removed first: a power cut in between leaves only the temporary file, which recoverFile() puts in place again.
+ * Call it only when the temporary file was written and closed without an error.
+ */
+inline bool replaceFile(const char* temporary, const char* path) {
+    if (rename(temporary, path) == 0) {
+        return true;
+    }
+    remove(path);
+    return rename(temporary, path) == 0;
+}
+
+/** Before reading `path`: when it is missing and `temporary` is there (see replaceFile), the temporary file becomes it. */
+inline void recoverFile(const char* path, const char* temporary) {
+    FILE* file = fopen(path, "rb");
+    if (file != nullptr) {
+        fclose(file);
+        return;
+    }
+    rename(temporary, path);
+}
+
+/** The same with the usual name of the temporary file, `<path>.tmp`. */
+inline void recoverFile(const char* path) {
+    char temporary[320];
+    if (snprintf(temporary, sizeof(temporary), "%s.tmp", path) < static_cast<int>(sizeof(temporary))) {
+        recoverFile(path, temporary);
+    }
+}
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/render/CacheIndex.cpp b/Apps/Maps/main/Source/render/CacheIndex.cpp
index 47af6e7..6b4dc05 100644
--- a/Apps/Maps/main/Source/render/CacheIndex.cpp
+++ b/Apps/Maps/main/Source/render/CacheIndex.cpp
@@ -139,7 +139,8 @@ bool CacheIndex::load(const uint8_t* data, size_t size) {
     }
     clock = readU32(data + 12);
     const uint8_t* cursor = data + 16;
-    for (uint32_t i = 0; i < stored && count < capacity; i++, cursor += ENTRY_BYTES) {
+    uint32_t visited = 0;
+    for (; visited < stored && count < capacity; visited++, cursor += ENTRY_BYTES) {
         const TileKey tile { cursor[0], static_cast<int>(readU32(cursor + 1)), static_cast<int>(readU32(cursor + 5)) };
         const uint32_t fileSize = readU32(cursor + 9);
         const uint32_t lastUse = readU32(cursor + 13);
@@ -150,7 +151,8 @@ bool CacheIndex::load(const uint8_t* data, size_t size) {
         total += fileSize;
         clock = lastUse > clock ? lastUse : clock;
     }
-    complete = true;
+    // Complete only when every stored entry was looked at; a file with more entries than capacity is not
+    complete = visited == stored;
     return true;
 }
 
diff --git a/Apps/Maps/main/Source/render/Compose.cpp b/Apps/Maps/main/Source/render/Compose.cpp
index b948f2f..eb8a1dc 100644
--- a/Apps/Maps/main/Source/render/Compose.cpp
+++ b/Apps/Maps/main/Source/render/Compose.cpp
@@ -78,7 +78,9 @@ void scaleView(const uint16_t* source, uint16_t* target, int width, int height,
 
 AffineView scaledView(double worldX, double worldY, int zoom, float scale, float anchorX, float anchorY, int width, int height,
     float cosine, float sine) {
-    const float inverse = 1.0f / scale;
+    // Two touch points on one pixel give scale 0: never divide by it, and never go below 1/16 (composeAffine's
+    // fixed-point steps take at most 16 source pixels per screen pixel)
+    const float inverse = 1.0f / (scale > 0.0625f ? scale : 0.0625f);
     // The screen centre lies (width / 2 - anchorX, height / 2 - anchorY) screen pixels from the anchor
     const double offsetX = width / 2.0 - anchorX;
     const double offsetY = height / 2.0 - anchorY;
@@ -148,6 +150,21 @@ uint16_t lerpRgb565(uint16_t from, uint16_t to, uint32_t weight) {
 
 int composeAffine(uint16_t* view, int width, int height, const AffineView& transform, TileLookup lookup, void* context, uint16_t placeholder,
     AffineScratch& scratch, bool bilinear, int rowBegin, int rowEnd) {
+    // A degenerate frame (scale near 0 from two touch points on one pixel, or not finite) would overflow the 16.16
+    // steps below: the view gets the placeholder instead. 16 source pixels per screen pixel is far beyond any pinch.
+    constexpr float MAX_STEP = 16.0f;
+    const float steps[4] = { transform.a, transform.b, transform.c, transform.d };
+    for (const float step : steps) {
+        if (!(std::fabs(step) <= MAX_STEP) || !std::isfinite(transform.centerX) || !std::isfinite(transform.centerY)) {
+            const int last = rowEnd < 0 ? height : std::min(rowEnd, height);
+            for (int y = std::max(0, rowBegin); y < last; y++) {
+                for (int x = 0; x < width; x++) {
+                    view[y * width + x] = placeholder;
+                }
+            }
+            return 0;
+        }
+    }
     // The tiles under the four screen corners bound the ones the view needs
     const float halfWidth = width / 2.0f;
     const float halfHeight = height / 2.0f;
diff --git a/Apps/Maps/main/Source/render/LabelLayout.cpp b/Apps/Maps/main/Source/render/LabelLayout.cpp
index e6025a4..2d70eec 100644
--- a/Apps/Maps/main/Source/render/LabelLayout.cpp
+++ b/Apps/Maps/main/Source/render/LabelLayout.cpp
@@ -62,13 +62,20 @@ bool labelFontCoversText(LabelFont* font, const char* text, uint16_t length) {
     return true;
 }
 
-constexpr int CELL = 8;
+/** The collision grid's cell in pixels. */
+constexpr int CELL = 4;
+/** The grid reaches this far beyond the screen: a label partly outside keeps its place, so nothing changes at the edge. */
+constexpr int MARGIN = 40;
+/** Map positions that must mean the same at every view zoom (a label's identity) are in pixels of this zoom. */
+constexpr int WORLD_ZOOM = 24;
 constexpr int MAX_LINE_POINTS = 6000;
 /** A line stretch is straight enough when no segment turns more than this from the stretch's direction. */
 constexpr float MAX_BEND = 0.42f;
 constexpr float PI = 3.14159265f;
 /** Space kept free around a label, so neighbours do not touch. */
 constexpr float GAP = 2.0f;
+/** Icons may stand closer together than names. */
+constexpr float ICON_GAP = 1.0f;
 constexpr int SIZE_SMALL = 0;
 constexpr int SIZE_NORMAL = 1;
 constexpr int SIZE_LARGE = 2;
@@ -78,6 +85,8 @@ enum Priority : uint8_t {
     PRIORITY_REGION,
     PRIORITY_CITY,
     PRIORITY_TOWN,
+    /** States and provinces: after the cities and towns, whose names matter more when both do not fit. */
+    PRIORITY_STATE,
     PRIORITY_VILLAGE,
     PRIORITY_SUBURB,
     PRIORITY_MAJOR_ROAD,
@@ -183,16 +192,67 @@ void LabelLayout::clear() {
     placedCount = 0;
 }
 
-void LabelLayout::beginView(int width, int height, int viewZoom) {
+void LabelLayout::screenToMap(double sx, double sy, double& mx, double& my) const {
+    if (viewSin == 0.0f && viewCos == 1.0f) {
+        // North up: the screen's corner is the origin (kept exactly as before, so unturned placements do not change)
+        mx = sx + originX;
+        my = sy + originY;
+        return;
+    }
+    const double dx = sx - screenWidth / 2.0;
+    const double dy = sy - screenHeight / 2.0;
+    mx = viewCenterX + viewCos * dx - viewSin * dy;
+    my = viewCenterY + viewSin * dx + viewCos * dy;
+}
+
+void LabelLayout::mapToScreen(double mx, double my, double& sx, double& sy) const {
+    if (viewSin == 0.0f && viewCos == 1.0f) {
+        sx = mx - originX;
+        sy = my - originY;
+        return;
+    }
+    const double dx = mx - viewCenterX;
+    const double dy = my - viewCenterY;
+    sx = screenWidth / 2.0 + viewCos * dx + viewSin * dy;
+    sy = screenHeight / 2.0 - viewSin * dx + viewCos * dy;
+}
+
+void LabelLayout::beginView(int width, int height, int viewZoom, double worldLeft, double worldTop) {
+    beginTurnedView(width, height, viewZoom, worldLeft, worldTop, worldLeft + width / 2.0, worldTop + height / 2.0, 1.0f, 0.0f);
+}
+
+void LabelLayout::beginTurnedView(int width, int height, int viewZoom, double worldLeft, double worldTop, double centerX, double centerY,
+    float cosine, float sine) {
+    if (placedCount > 0) {
+        // What is on screen now is remembered (by name and map position), so it keeps its place in the next placement
+        const double scale = std::ldexp(1.0, WORLD_ZOOM - zoom);
+        keptCount = 0;
+        for (int i = 0; i < placedCount; i++) {
+            const Placed& label = placed[i];
+            double mx;
+            double my;
+            screenToMap(label.x + label.width / 2.0, label.y + label.height / 2.0, mx, my);
+            kept[keptCount++] = { label.id, mx * scale, my * scale };
+        }
+    }
     screenWidth = width;
     screenHeight = height;
     zoom = viewZoom;
+    originX = worldLeft;
+    originY = worldTop;
+    viewCenterX = centerX;
+    viewCenterY = centerY;
+    viewCos = cosine;
+    viewSin = sine;
+    gridBaseX = std::floor((worldLeft - MARGIN) / CELL);
+    gridBaseY = std::floor((worldTop - MARGIN) / CELL);
+    pendingCount = 0;
     candidateCount = 0;
     recordCount = 0;
     linePointCount = 0;
     textsUsed = 0;
-    gridColumns = (width + CELL - 1) / CELL;
-    gridRows = (height + CELL - 1) / CELL;
+    gridColumns = (width + 2 * MARGIN + CELL - 1) / CELL + 1;
+    gridRows = (height + 2 * MARGIN + CELL - 1) / CELL + 1;
     if (gridColumns * gridRows > static_cast<int>(sizeof(grid) * 8)) {
         gridRows = static_cast<int>(sizeof(grid) * 8) / gridColumns;
     }
@@ -212,16 +272,25 @@ bool LabelLayout::wants(const LabelRecord& record, uint8_t& priority, uint8_t& f
                 case Value::continent:
                 case Value::country:
                     priority = PRIORITY_REGION;
-                    fontSize = SIZE_LARGE;
+                    // Large while whole countries fill the screen; from z5 the middle size, so the capitals and
+                    // large cities fit between the names of the countries (central Europe at z5 had no room for them)
+                    fontSize = zoom <= 4 ? SIZE_LARGE : SIZE_NORMAL;
                     return zoom <= 7;
                 case Value::state:
                 case Value::province:
-                    priority = PRIORITY_REGION;
+                    priority = PRIORITY_STATE;
                     return zoom >= 5 && zoom <= 8 && density == LabelDensity::Normal;
-                case Value::city:
+                case Value::city: {
                     priority = PRIORITY_CITY;
-                    fontSize = SIZE_LARGE;
-                    return zoom >= 4;
+                    // Zoomed out, only the cities that matter at that scale, by their rank (capitals and the largest
+                    // have 1 to 3, Bratislava or Krakow 5, regional centres 6 to 8): the same rule everywhere, so a
+                    // small city never shows where a capital next to it does not. All of them from z8.
+                    const int rank = record.rank < 0 ? 99 : record.rank;
+                    const int first = rank <= 2 ? 4 : (rank <= 3 ? 5 : (rank <= 5 ? 6 : (rank <= 7 ? 7 : 8)));
+                    // Zoomed out the cities are small next to the countries' names, and grow as the countries leave
+                    fontSize = zoom <= 6 ? SIZE_SMALL : (zoom == 7 ? SIZE_NORMAL : SIZE_LARGE);
+                    return zoom >= std::max(4, first);
+                }
                 case Value::town:
                     priority = PRIORITY_TOWN;
                     fontSize = SIZE_NORMAL;
@@ -411,6 +480,26 @@ void LabelLayout::addRecords(const uint8_t* bytes, size_t size, int count, const
                 continue;
             }
         }
+        {
+            // The label's own order among equals: its name and where it is on the map (to two pixels, so the same
+            // label from two tiles gets the same number)
+            uint32_t hash = 2166136261u;
+            for (uint16_t i = 0; i < length; i++) {
+                hash = (hash ^ static_cast<uint8_t>(name[i])) * 16777619u;
+            }
+            const float anchorX = candidate.line ? linePoints[2 * candidate.firstPoint] : candidate.x;
+            const float anchorY = candidate.line ? linePoints[2 * candidate.firstPoint + 1] : candidate.y;
+            // In pixels of WORLD_ZOOM, so the label has the same number at every view zoom
+            const double scale = std::ldexp(1.0, WORLD_ZOOM - zoom);
+            double mapX;
+            double mapY;
+            screenToMap(anchorX, anchorY, mapX, mapY);
+            const auto worldX = static_cast<int64_t>(std::floor(mapX * scale / 16.0 + 0.5));
+            const auto worldY = static_cast<int64_t>(std::floor(mapY * scale / 16.0 + 0.5));
+            hash = (hash ^ static_cast<uint32_t>(worldX)) * 16777619u;
+            hash = (hash ^ static_cast<uint32_t>(worldY)) * 16777619u;
+            candidate.order = hash;
+        }
         candidate.textOffset = static_cast<uint32_t>(textsUsed);
         candidate.textLength = length;
         memcpy(texts + textsUsed, name, length);
@@ -460,24 +549,54 @@ int LabelLayout::textWidth(LabelFont& font, const char* text, int length) {
     return (widthX16 + 8) >> 4;
 }
 
+bool LabelLayout::gridRange(float cx, float cy, float halfWidth, float halfHeight, int& left, int& top, int& right, int& bottom) const {
+    // Cells are fixed to the map, not to the screen: a label covers the same cells however the view is panned, so a
+    // pan never changes which labels fit (they jumped when the cells moved with the screen)
+    left = static_cast<int>(std::floor((static_cast<double>(cx - halfWidth) + originX) / CELL) - gridBaseX);
+    right = static_cast<int>(std::floor((static_cast<double>(cx + halfWidth) + originX) / CELL) - gridBaseX);
+    top = static_cast<int>(std::floor((static_cast<double>(cy - halfHeight) + originY) / CELL) - gridBaseY);
+    bottom = static_cast<int>(std::floor((static_cast<double>(cy + halfHeight) + originY) / CELL) - gridBaseY);
+    // What lies beyond the margin around the screen is not tracked: nothing can be seen there
+    left = std::max(left, 0);
+    top = std::max(top, 0);
+    right = std::min(right, gridColumns - 1);
+    bottom = std::min(bottom, gridRows - 1);
+    return left <= right && top <= bottom;
+}
+
+bool LabelLayout::onScreen(float cx, float cy, float halfWidth, float halfHeight) const {
+    return cx + halfWidth > 0.0f && cy + halfHeight > 0.0f && cx - halfWidth < screenWidth && cy - halfHeight < screenHeight;
+}
+
 bool LabelLayout::gridFree(float cx, float cy, float halfWidth, float halfHeight, float angle) const {
-    // A turned box is checked as squares of its height along its axis
+    if (angle == 0.0f) {
+        // Upright: exactly the box (as squares along the axis it reached half a height further at both ends)
+        int left, top, right, bottom;
+        if (!gridRange(cx, cy, halfWidth, halfHeight, left, top, right, bottom)) {
+            return true;
+        }
+        for (int row = top; row <= bottom; row++) {
+            for (int column = left; column <= right; column++) {
+                const int cell = row * gridColumns + column;
+                if ((grid[cell >> 5] >> (cell & 31)) & 1u) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    // A turned box is checked as squares of its height along its axis, the end squares inside the box
     const float ux = std::cos(angle);
     const float uy = std::sin(angle);
     const float step = std::max(2.0f, halfHeight);
-    for (float t = -halfWidth; t <= halfWidth + 0.01f; t += step) {
-        const float px = cx + ux * t;
-        const float py = cy + uy * t;
-        const int left = static_cast<int>(std::floor((px - halfHeight) / CELL));
-        const int right = static_cast<int>(std::floor((px + halfHeight) / CELL));
-        const int top = static_cast<int>(std::floor((py - halfHeight) / CELL));
-        const int bottom = static_cast<int>(std::floor((py + halfHeight) / CELL));
+    const float reach = std::max(0.0f, halfWidth - halfHeight);
+    for (float t = -reach; t <= reach + 0.01f; t += step) {
+        int left, top, right, bottom;
+        if (!gridRange(cx + ux * t, cy + uy * t, halfHeight, halfHeight, left, top, right, bottom)) {
+            continue;
+        }
         for (int row = top; row <= bottom; row++) {
             for (int column = left; column <= right; column++) {
-                if (row < 0 || column < 0 || row >= gridRows || column >= gridColumns) {
-                    // Labels stay inside the screen
-                    return false;
-                }
                 const int cell = row * gridColumns + column;
                 if ((grid[cell >> 5] >> (cell & 31)) & 1u) {
                     return false;
@@ -488,21 +607,24 @@ bool LabelLayout::gridFree(float cx, float cy, float halfWidth, float halfHeight
     return true;
 }
 
-void LabelLayout::gridMark(float cx, float cy, float halfWidth, float halfHeight, float angle) {
+void LabelLayout::gridMark(float cx, float cy, float halfWidth, float halfHeight, float angle, bool taken) {
     const float ux = std::cos(angle);
     const float uy = std::sin(angle);
     const float step = std::max(2.0f, halfHeight);
-    for (float t = -halfWidth; t <= halfWidth + 0.01f; t += step) {
-        const float px = cx + ux * t;
-        const float py = cy + uy * t;
-        const int left = std::max(0, static_cast<int>(std::floor((px - halfHeight) / CELL)));
-        const int right = std::min(gridColumns - 1, static_cast<int>(std::floor((px + halfHeight) / CELL)));
-        const int top = std::max(0, static_cast<int>(std::floor((py - halfHeight) / CELL)));
-        const int bottom = std::min(gridRows - 1, static_cast<int>(std::floor((py + halfHeight) / CELL)));
+    const float reach = angle == 0.0f ? 0.0f : std::max(0.0f, halfWidth - halfHeight);
+    for (float t = -reach; t <= reach + 0.01f; t += step) {
+        int left, top, right, bottom;
+        if (!gridRange(cx + ux * t, cy + uy * t, angle == 0.0f ? halfWidth : halfHeight, halfHeight, left, top, right, bottom)) {
+            continue;
+        }
         for (int row = top; row <= bottom; row++) {
             for (int column = left; column <= right; column++) {
                 const int cell = row * gridColumns + column;
-                grid[cell >> 5] |= 1u << (cell & 31);
+                if (taken) {
+                    grid[cell >> 5] |= 1u << (cell & 31);
+                } else {
+                    grid[cell >> 5] &= ~(1u << (cell & 31));
+                }
             }
         }
     }
@@ -536,55 +658,91 @@ bool LabelLayout::placePoint(const Candidate& candidate) {
     const float halfWidth = width / 2.0f + GAP;
     const float halfHeight = font->lineHeight() / 2.0f + GAP;
     // Peaks get their name above the point, places centred on it
-    const float centerY = candidate.priority == PRIORITY_PEAK ? candidate.y - halfHeight - 3.0f : candidate.y;
+    float centerX = candidate.x;
+    float centerY = candidate.priority == PRIORITY_PEAK ? candidate.y - halfHeight - 3.0f : candidate.y;
     if (!gridFree(candidate.x, centerY, halfWidth, halfHeight, 0.0f)) {
-        return false;
+        // Countries, cities and towns try just above, below and beside their point before they give up: a capital next
+        // to its country's name (Budapest under Magyarorszag) no longer loses to a small city with free space
+        if (candidate.priority > PRIORITY_TOWN) {
+            return false;
+        }
+        const float shift = 2.0f * halfHeight - GAP;
+        const float aside = halfWidth + 4.0f;
+        if (gridFree(candidate.x, candidate.y - shift, halfWidth, halfHeight, 0.0f)) {
+            centerY = candidate.y - shift;
+        } else if (gridFree(candidate.x, candidate.y + shift, halfWidth, halfHeight, 0.0f)) {
+            centerY = candidate.y + shift;
+        } else if (gridFree(candidate.x + aside, candidate.y, halfWidth, halfHeight, 0.0f)) {
+            centerX = candidate.x + aside;
+        } else if (gridFree(candidate.x - aside, candidate.y, halfWidth, halfHeight, 0.0f)) {
+            centerX = candidate.x - aside;
+        } else {
+            return false;
+        }
     }
-    if (!drawSprite(candidate, candidate.x, centerY, 0.0f, width)) {
+    // A label wholly in the margin beyond the screen takes its place (so nothing changes when it comes into view) but
+    // costs no sprite
+    if (onScreen(centerX, centerY, halfWidth, halfHeight) && !drawSprite(candidate, centerX, centerY, 0.0f, width)) {
         return false;
     }
-    gridMark(candidate.x, centerY, halfWidth, halfHeight, 0.0f);
+    gridMark(centerX, centerY, halfWidth, halfHeight, 0.0f);
     return true;
 }
 
-bool LabelLayout::placePoi(const Candidate& candidate) {
-    LabelFont* font = fontFor(candidate.fontSize);
-    if (font == nullptr || candidate.icon == nullptr) {
+bool LabelLayout::placePoiIcon(const Candidate& candidate) {
+    if (candidate.icon == nullptr) {
         return false;
     }
     // Chains repeat names (two shops of the same name a street apart): only a copy right next to it is the same POI
     const char* name = texts + candidate.textOffset;
-    for (int i = 0; i < placedCount; i++) {
-        const Placed& other = placed[i];
-        if (other.kind == LabelKind::Poi && other.poiType == candidate.poiType && strcmp(texts + other.textOffset, name) == 0 &&
-            std::fabs(other.anchorX - candidate.x) < 6.0f && std::fabs(other.anchorY - candidate.y) < 6.0f) {
+    for (int i = 0; i < pendingCount; i++) {
+        const Candidate& other = candidates[pending[i]];
+        if (other.poiType == candidate.poiType && strcmp(texts + other.textOffset, name) == 0 && std::fabs(other.x - candidate.x) < 6.0f &&
+            std::fabs(other.y - candidate.y) < 6.0f) {
             return false;
         }
     }
-    const float iconHalf = candidate.iconSize / 2.0f + GAP;
-    // Where even the icon has no room, nothing is measured or drawn
+    const float iconHalf = candidate.iconSize / 2.0f + ICON_GAP;
     if (!gridFree(candidate.x, candidate.y, iconHalf, iconHalf, 0.0f)) {
         return false;
     }
-    // The name to the right of the icon when zoomed in and there is room, else the icon alone
-    if (zoom >= POI_NAME_ZOOM && candidate.textLength > 0) {
-        const int textPixels = candidateWidth(*font, candidate);
-        const float contentWidth = candidate.iconSize + 3.0f + textPixels;
-        const float centerX = candidate.x - candidate.iconSize / 2.0f + contentWidth / 2.0f;
-        const float halfHeight = std::max(iconHalf, font->lineHeight() / 2.0f + GAP);
-        if (gridFree(centerX, candidate.y, contentWidth / 2.0f + GAP, halfHeight, 0.0f) &&
-            drawSprite(candidate, centerX, candidate.y, 0.0f, textPixels, true)) {
-            gridMark(centerX, candidate.y, contentWidth / 2.0f + GAP, halfHeight, 0.0f);
-            return true;
-        }
-    }
-    if (!drawSprite(candidate, candidate.x, candidate.y, 0.0f, 0, false)) {
-        return false;
-    }
     gridMark(candidate.x, candidate.y, iconHalf, iconHalf, 0.0f);
     return true;
 }
 
+void LabelLayout::finishPois() {
+    // Every icon that fits has its place now. Names come second, where room is left next to an icon: a name never
+    // costs a neighbour its icon (the sheet of a POI shows its name anyway).
+    for (int i = 0; i < pendingCount && placedCount < MAX_LABELS; i++) {
+        const Candidate& candidate = candidates[pending[i]];
+        LabelFont* font = fontFor(candidate.fontSize);
+        const float iconHalf = candidate.iconSize / 2.0f + ICON_GAP;
+        if (font != nullptr && zoom >= POI_NAME_ZOOM && candidate.textLength > 0) {
+            const int textPixels = candidateWidth(*font, candidate);
+            const float contentWidth = candidate.iconSize + 3.0f + textPixels;
+            const float centerX = candidate.x - candidate.iconSize / 2.0f + contentWidth / 2.0f;
+            const float halfHeight = std::max(iconHalf, font->lineHeight() / 2.0f + GAP);
+            // Its own icon's cells are its own: taken out for the test of the icon and name together
+            gridMark(candidate.x, candidate.y, iconHalf, iconHalf, 0.0f, false);
+            if (gridFree(centerX, candidate.y, contentWidth / 2.0f + GAP, halfHeight, 0.0f) &&
+                (!onScreen(centerX, candidate.y, contentWidth / 2.0f, halfHeight) ||
+                    drawSprite(candidate, centerX, candidate.y, 0.0f, textPixels, true))) {
+                gridMark(centerX, candidate.y, contentWidth / 2.0f + GAP, halfHeight, 0.0f);
+                continue;
+            }
+            gridMark(candidate.x, candidate.y, iconHalf, iconHalf, 0.0f);
+        }
+        if (!onScreen(candidate.x, candidate.y, iconHalf, iconHalf)) {
+            continue;   // in the margin: its place is kept, nothing is drawn
+        }
+        if (!drawSprite(candidate, candidate.x, candidate.y, 0.0f, 0, false)) {
+            // The sprite arena is full: the place is given back
+            gridMark(candidate.x, candidate.y, iconHalf, iconHalf, 0.0f, false);
+        }
+    }
+    pendingCount = 0;
+}
+
 int LabelLayout::placeLine(const Candidate& candidate) {
     LabelFont* font = fontFor(candidate.fontSize);
     if (font == nullptr) {
@@ -596,7 +754,8 @@ int LabelLayout::placeLine(const Candidate& candidate) {
     const float needed = static_cast<float>(width) + 8.0f;
     const float halfHeight = font->lineHeight() / 2.0f + GAP;
     // Distance along the line at each point
-    float lengths[LabelReader::MAX_POINTS];
+    // Not on the stack (1 KB): the map loop's task has little of it left
+    float* lengths = lineLengths;
     lengths[0] = 0.0f;
     const int used = std::min(count, LabelReader::MAX_POINTS);
     for (int i = 1; i < used; i++) {
@@ -605,7 +764,9 @@ int LabelLayout::placeLine(const Candidate& candidate) {
         lengths[i] = lengths[i - 1] + std::sqrt(dx * dx + dy * dy);
     }
     const float total = lengths[used - 1];
-    if (total < needed) {
+    // A damaged label file can give points far away: beyond this the 16 px steps below no longer add up in a float
+    // and the loop never ended (found by host/fuzz_tests). No real line on screen is that long.
+    if (total < needed || !(total < 200000.0f)) {
         return 0;
     }
     auto pointAt = [&](float distance, float& x, float& y, int& segment) {
@@ -618,8 +779,8 @@ int LabelLayout::placeLine(const Candidate& candidate) {
         x = points[2 * segment - 2] + (points[2 * segment] - points[2 * segment - 2]) * t;
         y = points[2 * segment - 1] + (points[2 * segment + 1] - points[2 * segment - 1]) * t;
     };
-    int placedHere = 0;
-    for (float start = 0.0f; start + needed <= total && placedCount < MAX_LABELS;) {
+    // One stretch of the line starting at a distance along it: placed there when it is straight, on screen and free
+    auto tryAt = [&](float start, const float* nearX, const float* nearY) {
         float x0;
         float y0;
         float x1;
@@ -628,6 +789,14 @@ int LabelLayout::placeLine(const Candidate& candidate) {
         int last;
         pointAt(start, x0, y0, first);
         pointAt(start + needed, x1, y1, last);
+        const float centerX = (x0 + x1) / 2.0f;
+        const float centerY = (y0 + y1) / 2.0f;
+        if (centerX < halfHeight || centerY < halfHeight || centerX > screenWidth - halfHeight || centerY > screenHeight - halfHeight) {
+            return false;
+        }
+        if (nearX != nullptr && (std::fabs(centerX - *nearX) > 10.0f || std::fabs(centerY - *nearY) > 10.0f)) {
+            return false;
+        }
         const float chordX = x1 - x0;
         const float chordY = y1 - y0;
         const float chord = std::sqrt(chordX * chordX + chordY * chordY);
@@ -646,12 +815,6 @@ int LabelLayout::placeLine(const Candidate& candidate) {
             }
             straight = bend <= MAX_BEND;
         }
-        const float centerX = (x0 + x1) / 2.0f;
-        const float centerY = (y0 + y1) / 2.0f;
-        if (centerX < halfHeight || centerY < halfHeight || centerX > screenWidth - halfHeight || centerY > screenHeight - halfHeight) {
-            start += 16.0f;
-            continue;
-        }
         // Upright: text never runs from right to left
         float upright = angle;
         if (upright > PI / 2.0f) {
@@ -662,6 +825,34 @@ int LabelLayout::placeLine(const Candidate& candidate) {
         if (straight && !alreadyPlaced(candidate, centerX, centerY) && gridFree(centerX, centerY, width / 2.0f + GAP, halfHeight, upright) &&
             drawSprite(candidate, centerX, centerY, upright, width)) {
             gridMark(centerX, centerY, width / 2.0f + GAP, halfHeight, upright);
+            return true;
+        }
+        return false;
+    };
+    int placedHere = 0;
+    // A name that was on screen keeps its stretch while that is still good: otherwise it slid along its street with
+    // every pan, to the first stretch on screen, and pushed other labels away
+    if (candidate.sticky) {
+        const double scale = std::ldexp(1.0, zoom - WORLD_ZOOM);
+        for (int k = 0; k < keptCount && placedCount < MAX_LABELS; k++) {
+            if (kept[k].id != candidate.order) {
+                continue;
+            }
+            double screenX;
+            double screenY;
+            mapToScreen(kept[k].worldX * scale, kept[k].worldY * scale, screenX, screenY);
+            const auto nearX = static_cast<float>(screenX);
+            const auto nearY = static_cast<float>(screenY);
+            for (float start = 0.0f; start + needed <= total; start += 16.0f) {
+                if (tryAt(start, &nearX, &nearY)) {
+                    placedHere++;
+                    break;
+                }
+            }
+        }
+    }
+    for (float start = 0.0f; start + needed <= total && placedCount < MAX_LABELS;) {
+        if (tryAt(start, nullptr, nullptr)) {
             placedHere++;
             start += needed + LINE_REPEAT_PIXELS;
         } else {
@@ -691,7 +882,36 @@ bool LabelLayout::drawSprite(const Candidate& candidate, float centerX, float ce
         return false; // a steep line label's turned box would stick out of the screen
     }
     const size_t bytes = static_cast<size_t>(width) * height * 2;
-    if (arenaUsed + bytes + 2 * static_cast<size_t>(width) * height > ARENA_BYTES) {
+    // An icon without a name looks the same wherever it is: the sprite drawn for the first one serves the others
+    const bool shared = !withText && iconSize > 0 && angle == 0.0f;
+    int sharedAt = -1;
+    for (int i = 0; shared && i < iconSpriteCount && sharedAt < 0; i++) {
+        if (iconSprites[i].icon == candidate.icon && iconSprites[i].size == iconSize) {
+            sharedAt = i;
+        }
+    }
+    auto finish = [&](uint32_t spriteOffset) {
+        Placed& label = placed[placedCount++];
+        label.textOffset = candidate.textOffset;
+        label.x = static_cast<int16_t>(std::floor(centerX - width / 2.0f + 0.5f));
+        label.y = static_cast<int16_t>(std::floor(centerY - height / 2.0f + 0.5f));
+        label.width = static_cast<int16_t>(width);
+        label.height = static_cast<int16_t>(height);
+        label.color = candidate.color;
+        label.line = candidate.line;
+        label.spriteOffset = spriteOffset;
+        label.kind = candidate.kind;
+        label.poiType = candidate.poiType;
+        label.id = candidate.order;
+        label.anchorX = static_cast<int16_t>(std::clamp(candidate.x, -30000.0f, 30000.0f));
+        label.anchorY = static_cast<int16_t>(std::clamp(candidate.y, -30000.0f, 30000.0f));
+    };
+    if (sharedAt >= 0) {
+        finish(iconSprites[sharedAt].offset);
+        return true;
+    }
+    // The sprite's two planes, two more to work in and two numbers a row (the halo below)
+    if (arenaUsed + bytes + 2 * static_cast<size_t>(width) * height + 4 * static_cast<size_t>(height) + 2 > ARENA_BYTES) {
         return false;
     }
     const uint32_t started = clock != nullptr ? clock() : 0;
@@ -798,53 +1018,108 @@ bool LabelLayout::drawSprite(const Candidate& candidate, float centerX, float ce
         }
         penX16 += glyph.advanceX16;
     }
-    // The halo: the text grown by one pixel, and half as strong one more pixel out
-    uint8_t* scratch = haloPlane + static_cast<size_t>(width) * height;
-    uint8_t* scratch2 = scratch + static_cast<size_t>(width) * height;
-    // A 3 x 3 maximum: by rows into rows, then by columns into to
-    auto grow = [&](const uint8_t* from, uint8_t* to, uint8_t* rows) {
-        for (int y = 0; y < height; y++) {
-            const uint8_t* in = from + y * width;
-            uint8_t* out = rows + y * width;
-            for (int x = 0; x < width; x++) {
-                uint8_t value = in[x];
-                if (x > 0 && in[x - 1] > value) {
-                    value = in[x - 1];
-                }
-                if (x + 1 < width && in[x + 1] > value) {
-                    value = in[x + 1];
-                }
-                out[x] = value;
+    // The halo: the text grown by one pixel, and half as strong one more pixel out. That is the largest value within
+    // one pixel, or half the largest within two, whichever is more. Both are found in two passes, along the rows and
+    // then down the columns, and only where a row has text: most of a sprite is empty (all of it but a band, for a
+    // name turned along its street), and going over every pixel five times was more than half the time of drawing
+    // the labels of a view (0.43 us a pixel on the T-Deck, 13-21 ms a view, 15 Nov).
+    const size_t plane = static_cast<size_t>(width) * height;
+    uint8_t* near = haloPlane + plane;   // the largest of a pixel and its two neighbours in the row
+    uint8_t* far = near + plane;         // and of the two on each side
+    // (at an even address: the arena's sprites have any size)
+    auto* rowLow = reinterpret_cast<int16_t*>(far + plane + ((reinterpret_cast<uintptr_t>(far) + plane) & 1));
+    int16_t* rowHigh = rowLow + height;
+    memset(near, 0, 2 * plane);
+    memset(haloPlane, 0, plane);
+    for (int y = 0; y < height; y++) {
+        const uint8_t* in = textPlane + y * width;
+        int low = 0;
+        while (low < width && in[low] == 0) {
+            low++;
+        }
+        int high = width - 1;
+        while (high >= low && in[high] == 0) {
+            high--;
+        }
+        if (high < low) {
+            rowLow[y] = static_cast<int16_t>(width);
+            rowHigh[y] = -1;
+            continue;
+        }
+        low = std::max(0, low - 2);
+        high = std::min(width - 1, high + 2);
+        rowLow[y] = static_cast<int16_t>(low);
+        rowHigh[y] = static_cast<int16_t>(high);
+        uint8_t* out3 = near + y * width;
+        uint8_t* out5 = far + y * width;
+        for (int x = low; x <= high; x++) {
+            uint8_t three = in[x];
+            if (x > 0 && in[x - 1] > three) {
+                three = in[x - 1];
+            }
+            if (x + 1 < width && in[x + 1] > three) {
+                three = in[x + 1];
             }
+            uint8_t five = three;
+            if (x > 1 && in[x - 2] > five) {
+                five = in[x - 2];
+            }
+            if (x + 2 < width && in[x + 2] > five) {
+                five = in[x + 2];
+            }
+            out3[x] = three;
+            out5[x] = five;
+        }
+    }
+    for (int y = 0; y < height; y++) {
+        // The columns that any of the five rows around this one has text in
+        int low = width;
+        int high = -1;
+        for (int row = std::max(0, y - 2); row <= std::min(height - 1, y + 2); row++) {
+            low = std::min<int>(low, rowLow[row]);
+            high = std::max<int>(high, rowHigh[row]);
         }
-        for (int y = 0; y < height; y++) {
-            const uint8_t* above = rows + (y > 0 ? y - 1 : y) * width;
-            const uint8_t* here = rows + y * width;
-            const uint8_t* below = rows + (y + 1 < height ? y + 1 : y) * width;
-            uint8_t* out = to + y * width;
-            for (int x = 0; x < width; x++) {
-                out[x] = std::max(here[x], std::max(above[x], below[x]));
+        if (high < low) {
+            continue;
+        }
+        const uint8_t* n0 = near + (y > 0 ? y - 1 : y) * width;
+        const uint8_t* n1 = near + y * width;
+        const uint8_t* n2 = near + (y + 1 < height ? y + 1 : y) * width;
+        const uint8_t* f0 = far + std::max(0, y - 2) * width;
+        const uint8_t* f1 = far + std::max(0, y - 1) * width;
+        const uint8_t* f2 = far + y * width;
+        const uint8_t* f3 = far + std::min(height - 1, y + 1) * width;
+        const uint8_t* f4 = far + std::min(height - 1, y + 2) * width;
+        uint8_t* out = haloPlane + y * width;
+        for (int x = low; x <= high; x++) {
+            uint8_t one = n1[x];
+            if (n0[x] > one) {
+                one = n0[x];
+            }
+            if (n2[x] > one) {
+                one = n2[x];
+            }
+            uint8_t two = f2[x];
+            if (f0[x] > two) {
+                two = f0[x];
             }
+            if (f1[x] > two) {
+                two = f1[x];
+            }
+            if (f3[x] > two) {
+                two = f3[x];
+            }
+            if (f4[x] > two) {
+                two = f4[x];
+            }
+            two = static_cast<uint8_t>(two / 2);
+            out[x] = one > two ? one : two;
         }
-    };
-    grow(textPlane, haloPlane, scratch);
-    grow(haloPlane, scratch, scratch2);
-    for (int i = 0; i < width * height; i++) {
-        haloPlane[i] = std::max(haloPlane[i], static_cast<uint8_t>(scratch[i] / 2));
-    }
-    Placed& label = placed[placedCount++];
-    label.textOffset = candidate.textOffset;
-    label.x = static_cast<int16_t>(std::floor(centerX - width / 2.0f + 0.5f));
-    label.y = static_cast<int16_t>(std::floor(centerY - height / 2.0f + 0.5f));
-    label.width = static_cast<int16_t>(width);
-    label.height = static_cast<int16_t>(height);
-    label.color = candidate.color;
-    label.line = candidate.line;
-    label.spriteOffset = static_cast<uint32_t>(arenaUsed);
-    label.kind = candidate.kind;
-    label.poiType = candidate.poiType;
-    label.anchorX = static_cast<int16_t>(std::clamp(candidate.x, -30000.0f, 30000.0f));
-    label.anchorY = static_cast<int16_t>(std::clamp(candidate.y, -30000.0f, 30000.0f));
+    }
+    finish(static_cast<uint32_t>(arenaUsed));
+    if (shared && iconSpriteCount < ICON_SPRITES) {
+        iconSprites[iconSpriteCount++] = { candidate.icon, static_cast<uint32_t>(arenaUsed), static_cast<int16_t>(iconSize) };
+    }
     arenaUsed += bytes;
     if (clock != nullptr) {
         spriteTime += clock() - started;
@@ -855,27 +1130,67 @@ bool LabelLayout::drawSprite(const Candidate& candidate, float centerX, float ce
 int LabelLayout::place() {
     placedCount = 0;
     arenaUsed = 0;
+    iconSpriteCount = 0;
     spriteTime = 0;
     memset(grid, 0, sizeof(grid));
     if (candidates == nullptr || density == LabelDensity::Off) {
         return 0;
     }
     // The most important first; within a kind the lower rank first
+    // The most important first; within a kind the lower rank first. Equal ones in an order that depends only on the
+    // label itself (its name and its place on the map), never on the order the tiles were read in: the same view
+    // always gives the same labels
+    // Among the small things (suburbs, streets, POIs, house numbers) what was on screen in the last placement comes
+    // first: it stays where it is while the map moves or zooms, and new ones fill the room that is left. Countries,
+    // cities, towns and villages always go by rank.
+    for (int i = 0; i < candidateCount; i++) {
+        Candidate& candidate = candidates[i];
+        candidate.sticky = false;
+        if (candidate.priority >= PRIORITY_SUBURB) {
+            for (int k = 0; k < keptCount; k++) {
+                if (kept[k].id == candidate.order) {
+                    candidate.sticky = true;
+                    break;
+                }
+            }
+        }
+    }
     std::sort(candidates, candidates + candidateCount, [](const Candidate& a, const Candidate& b) {
         if (a.priority != b.priority) {
             return a.priority < b.priority;
         }
-        return a.rank < b.rank;
+        if (a.sticky != b.sticky) {
+            return a.sticky;
+        }
+        if (a.rank != b.rank) {
+            return a.rank < b.rank;
+        }
+        if (a.order != b.order) {
+            return a.order < b.order;
+        }
+        return a.textOffset < b.textOffset;
     });
-    for (int i = 0; i < candidateCount && placedCount < MAX_LABELS; i++) {
+    bool poisOpen = false;
+    for (int i = 0; i < candidateCount && placedCount + pendingCount < MAX_LABELS; i++) {
+        if (candidates[i].kind == LabelKind::Poi) {
+            // Icons first, all of them; their names when the last POI had its turn
+            poisOpen = true;
+            if (placePoiIcon(candidates[i])) {
+                pending[pendingCount++] = static_cast<uint16_t>(i);
+            }
+            continue;
+        }
+        if (poisOpen) {
+            finishPois();
+            poisOpen = false;
+        }
         if (candidates[i].line) {
             placeLine(candidates[i]);
-        } else if (candidates[i].kind == LabelKind::Poi) {
-            placePoi(candidates[i]);
         } else {
             placePoint(candidates[i]);
         }
     }
+    finishPois();
     return placedCount;
 }
 
@@ -958,15 +1273,23 @@ int LabelLayout::pick(int x, int y, int radius, int offsetX, int offsetY) const
 int LabelLayout::byDistance(int x, int y, int* out, int max, int offsetX, int offsetY) const {
     int count = 0;
     int distances[MAX_LABELS];
-    for (int i = 0; i < placedCount && count < max && count < MAX_LABELS; i++) {
+    const int capacity = max < MAX_LABELS ? max : MAX_LABELS;
+    for (int i = 0; i < placedCount && capacity > 0; i++) {
         const Placed& label = placed[i];
         if (label.kind != LabelKind::Poi && label.kind != LabelKind::HouseNumber) {
             continue;
         }
         const int dx = label.anchorX + offsetX - x;
         const int dy = label.anchorY + offsetY - y;
-        // Insertion into the sorted list, nearest first
+        // Insertion into the sorted list, nearest first. Every label is looked at, because the
+        // nearest one can come late in placement order; when the list is full the farthest drops out.
         const int distance = dx * dx + dy * dy;
+        if (count == capacity) {
+            if (distance >= distances[count - 1]) {
+                continue;
+            }
+            count--;
+        }
         int at = count++;
         while (at > 0 && distances[at - 1] > distance) {
             distances[at] = distances[at - 1];
diff --git a/Apps/Maps/main/Source/render/LabelLayout.h b/Apps/Maps/main/Source/render/LabelLayout.h
index 1cd66ed..ebf77f0 100644
--- a/Apps/Maps/main/Source/render/LabelLayout.h
+++ b/Apps/Maps/main/Source/render/LabelLayout.h
@@ -127,7 +127,17 @@ class LabelLayout {
     void setPoiLookup(PoiLookup value) { poiLookup = value; }
 
     /** Starts a new placement for a screen of width x height at a view zoom level. */
-    void beginView(int width, int height, int viewZoom);
+    /**
+     * worldLeft and worldTop: the map position of the screen's top left corner in pixels of the view's zoom. With
+     * them the placement is the same wherever the view is panned to; without (0, 0) it is tied to the screen.
+     */
+    void beginView(int width, int height, int viewZoom, double worldLeft = 0.0, double worldTop = 0.0);
+    /**
+     * The same for a turned map: the screen centre's map position and the bearing's cosine and sine (screen offset =
+     * [cos sin; -sin cos] x map offset, as the label transforms). Labels keep their identity and place across pans.
+     */
+    void beginTurnedView(int width, int height, int viewZoom, double worldLeft, double worldTop, double centerX, double centerY,
+        float cosine, float sine);
     /**
      * Adds the labels of one source tile's label section. With cells (a split tile's label file) only the POI and house
      * number cells near the screen are read.
@@ -142,6 +152,8 @@ class LabelLayout {
     void draw(Canvas& canvas, int offsetX, int offsetY, bool lineLabels) const;
     int count() const { return placedCount; }
     int candidateTotal() const { return candidateCount; }
+    /** Tests: the identity (name and map position hash) of candidate i of the last view. */
+    uint32_t candidateOrder(int index) const { return candidates[index].order; }
     /** Records read by the addSection() calls since beginView(), for the log. */
     int recordsRead() const { return recordCount; }
     /** Time the last place() spent drawing sprites, set through setClock(). */
@@ -180,6 +192,10 @@ class LabelLayout {
         uint8_t poiType;
         uint8_t iconSize;
         const uint8_t* icon;
+        /** Order among candidates of the same priority and rank, from the name and the map position: the label's identity. */
+        uint32_t order;
+        /** It was on screen in the last placement. */
+        bool sticky;
     };
     struct Placed {
         uint32_t textOffset;
@@ -195,6 +211,14 @@ class LabelLayout {
         /** The labelled point on screen when placed (for POIs and house numbers). */
         int16_t anchorX;
         int16_t anchorY;
+        /** The candidate's order number. */
+        uint32_t id;
+    };
+    /** A label of the last placement: its identity and its centre on the map (pixels of zoom 24). */
+    struct Kept {
+        uint32_t id;
+        double worldX;
+        double worldY;
     };
 
     bool wants(const LabelRecord& record, uint8_t& priority, uint8_t& fontSize, uint16_t& color) const;
@@ -209,10 +233,16 @@ class LabelLayout {
     };
     static constexpr int WIDTH_ENTRIES = 1024;
     WidthEntry* widths = nullptr;
+    /** The cells a box covers, cut to the grid; false when it lies outside it. */
+    bool gridRange(float cx, float cy, float halfWidth, float halfHeight, int& left, int& top, int& right, int& bottom) const;
+    /** Whether any part of a box is on the screen. */
+    bool onScreen(float cx, float cy, float halfWidth, float halfHeight) const;
     bool gridFree(float cx, float cy, float halfWidth, float halfHeight, float angle) const;
-    void gridMark(float cx, float cy, float halfWidth, float halfHeight, float angle);
+    void gridMark(float cx, float cy, float halfWidth, float halfHeight, float angle, bool taken = true);
     bool placePoint(const Candidate& candidate);
-    bool placePoi(const Candidate& candidate);
+    /** Takes the place of a POI's icon; its sprite (with the name where there is room) is drawn by finishPois(). */
+    bool placePoiIcon(const Candidate& candidate);
+    void finishPois();
     int placeLine(const Candidate& candidate);
     /** Draws text turned by angle (radians) around the centre of a new sprite; false when the arena is full. */
     bool drawSprite(const Candidate& candidate, float centerX, float centerY, float angle, int textPixels, bool withText = true);
@@ -222,6 +252,18 @@ class LabelLayout {
     void (*releaseMemory)(void*) = nullptr;
     uint8_t* arena = nullptr;
     size_t arenaUsed = 0;
+    /**
+     * The sprites of POI icons drawn without a name in this pass: every POI of a kind shows the same icon, so its
+     * sprite (mask and halo) is drawn once and shared (at zoom 17 most labels are such icons).
+     */
+    struct IconSprite {
+        const uint8_t* icon;
+        uint32_t offset;
+        int16_t size;
+    };
+    static constexpr int ICON_SPRITES = 48;
+    IconSprite iconSprites[ICON_SPRITES] = {};
+    int iconSpriteCount = 0;
     char* texts = nullptr;
     size_t textsUsed = 0;
     Candidate* candidates = nullptr;
@@ -230,8 +272,27 @@ class LabelLayout {
     int linePointCount = 0;
     Placed placed[MAX_LABELS] {};
     int placedCount = 0;
-    /** One bit per 8 x 8 pixel cell of the screen. */
-    uint32_t grid[128] {};
+    /** One bit per cell of the screen and a margin around it; the cells are fixed to the map (see gridRange). */
+    uint32_t grid[1024] {};
+    double originX = 0.0;
+    double originY = 0.0;
+    /** The view's turn (cos 1, sin 0 when north is up) and its centre on the map, for screenToMap / mapToScreen. */
+    double viewCenterX = 0.0;
+    double viewCenterY = 0.0;
+    float viewCos = 1.0f;
+    float viewSin = 0.0f;
+    /** Map pixels (of this view's zoom) of a screen point, and back; the same frame for every pan at one bearing. */
+    void screenToMap(double sx, double sy, double& mx, double& my) const;
+    void mapToScreen(double mx, double my, double& sx, double& sy) const;
+    double gridBaseX = 0.0;
+    double gridBaseY = 0.0;
+    /** POIs whose icon has a place, as candidate indexes, until finishPois() draws them. */
+    uint16_t pending[MAX_LABELS] {};
+    int pendingCount = 0;
+    Kept kept[MAX_LABELS] {};
+    /** placeLine's distances along the line it is placing. */
+    float lineLengths[LabelReader::MAX_POINTS] {};
+    int keptCount = 0;
     int gridColumns = 0;
     int gridRows = 0;
     int screenWidth = 0;
diff --git a/Apps/Maps/main/Source/render/PreparedTile.cpp b/Apps/Maps/main/Source/render/PreparedTile.cpp
index 479299e..f583131 100644
--- a/Apps/Maps/main/Source/render/PreparedTile.cpp
+++ b/Apps/Maps/main/Source/render/PreparedTile.cpp
@@ -124,6 +124,9 @@ bool readPreparedHeader(const uint8_t* data, size_t size, PreparedHeader& header
     header.sourceSize = readU32(data + 20);
     header.bodySize = readU32(data + 24);
     header.storedSize = readU32(data + 28);
+    if (header.bodySize > PREPARED_MAX_SECTION || header.storedSize > PREPARED_MAX_SECTION) {
+        return false;   // damaged: sums with these sizes must not wrap
+    }
     memcpy(header.sourceVersion, data + 32, PREPARED_VERSION_LENGTH);
     header.sourceVersion[PREPARED_VERSION_LENGTH] = '\0';
     return true;
@@ -134,7 +137,7 @@ bool isPreparedCurrent(const PreparedHeader& header, const TileKey& tile, uint32
 }
 
 uint8_t preparedPartsNeeded(const PreparedHeader* header, const TileKey& tile, uint32_t sourceSize) {
-    const uint8_t graph = tile.z == GRAPH_ZOOM && PREPARED_GRAPH_FORMAT_VERSION != 0 ? PART_GRAPH : 0;
+    const uint8_t graph = tileHasGraph(tile.z) && PREPARED_GRAPH_FORMAT_VERSION != 0 ? PART_GRAPH : 0;
     if (header == nullptr || !(header->tile == tile) || header->sourceSize != sourceSize || header->extent != PREPARED_EXTENT) {
         return PART_GEOMETRY | PART_LABELS | graph;
     }
@@ -167,6 +170,10 @@ bool readPreparedLabelHeader(const uint8_t* data, size_t size, PreparedLabelHead
     header.numberCount = readU32(data + 36);
     header.numberSize = readU32(data + 40);
     header.numberStored = readU32(data + 44);
+    if (header.mainSize > PREPARED_MAX_SECTION || header.mainStored > PREPARED_MAX_SECTION || header.numberSize > PREPARED_MAX_SECTION ||
+        header.numberStored > PREPARED_MAX_SECTION) {
+        return false;   // damaged: sums with these sizes must not wrap
+    }
     memcpy(header.sourceVersion, data + 48, PREPARED_VERSION_LENGTH);
     header.sourceVersion[PREPARED_VERSION_LENGTH] = '\0';
     return true;
@@ -586,7 +593,7 @@ bool TileConverter::writeGeometry(const char* sourceVersion, uint32_t sourceSize
     out.putBytes(MAGIC, 4);
     out.putU16(withLabels ? PREPARED_SPLIT_VERSION - 1 : PREPARED_FORMAT_VERSION);
     // The companion versions this tile was made with (version 5 on)
-    const auto graphVersion = static_cast<uint16_t>(withLabels || tile.z != GRAPH_ZOOM ? 0 : PREPARED_GRAPH_FORMAT_VERSION);
+    const auto graphVersion = static_cast<uint16_t>(withLabels || !tileHasGraph(tile.z) ? 0 : PREPARED_GRAPH_FORMAT_VERSION);
     out.putU16(static_cast<uint16_t>((deflate ? PREPARED_FLAG_DEFLATED : 0) | (graphVersion << 8)));
     out.put(static_cast<uint8_t>(tile.z));
     out.put(withLabels ? 0 : PREPARED_LABEL_FORMAT_VERSION);
diff --git a/Apps/Maps/main/Source/render/PreparedTile.h b/Apps/Maps/main/Source/render/PreparedTile.h
index 110aa97..8ed1054 100644
--- a/Apps/Maps/main/Source/render/PreparedTile.h
+++ b/Apps/Maps/main/Source/render/PreparedTile.h
@@ -55,6 +55,8 @@ constexpr uint8_t PREPARED_LABEL_SECTION = 10;
 constexpr int PREPARED_EXTENT = 2048;
 constexpr size_t PREPARED_HEADER_SIZE = 64;
 constexpr size_t PREPARED_VERSION_LENGTH = 32;
+/** No section of a prepared file is larger (inflated or stored): a header with more is damaged. */
+constexpr uint32_t PREPARED_MAX_SECTION = 16u * 1024u * 1024u;
 constexpr uint16_t PREPARED_FLAG_DEFLATED = 1;
 
 /**
@@ -72,6 +74,14 @@ constexpr size_t PREPARED_LABEL_HEADER_SIZE = 80;
 constexpr uint8_t PREPARED_GRAPH_FORMAT_VERSION = 1;
 /** Only tiles of this zoom have a routing graph. */
 constexpr int GRAPH_ZOOM = 14;
+/**
+ * Tiles of this zoom get a routing graph as well (0.6.0, M5c-5): they hold only the main roads (motorway to
+ * secondary), 16 times the ground per tile, for the part of a long route between its two ends.
+ */
+constexpr int GRAPH_MAIN_ZOOM = 10;
+inline bool tileHasGraph(int zoom) {
+    return zoom == GRAPH_ZOOM || zoom == GRAPH_MAIN_ZOOM;
+}
 
 struct PreparedLabelHeader {
     uint16_t version;
diff --git a/Apps/Maps/main/Source/route/RouteFollower.cpp b/Apps/Maps/main/Source/route/RouteFollower.cpp
index a688290..26d8bb4 100644
--- a/Apps/Maps/main/Source/route/RouteFollower.cpp
+++ b/Apps/Maps/main/Source/route/RouteFollower.cpp
@@ -299,6 +299,19 @@ const RouteFollower::Status& RouteFollower::update(const Route& route, double la
     const float segmentMetres = route.distances[segment + 1] - route.distances[segment];
     const float progress = route.distances[segment] + t * segmentMetres;
     current.distanceFromRouteM = distance;
+    // On the main-road layer the route's line is the z10 tile's: up to some tens of metres beside the real road.
+    // There only a larger distance counts as away, and the heading and edge rules (made for the map's own lines)
+    // are left out
+    bool coarse = false;
+    for (const RouteStep& step : route.steps) {
+        if (step.point > segment) {
+            break;
+        }
+        coarse = (step.flags & ROUTE_STEP_COARSE) != 0;
+    }
+    const float offHere = coarse ? off + COARSE_EXTRA_M : off;
+    const float matchLimitHere = std::max(matchLimit, offHere);
+    current.offM = offHere;
 
     // The direction of travel against the route's at the matched segment
     const RoutePoint& a = route.points[segment];
@@ -356,8 +369,8 @@ const RouteFollower::Status& RouteFollower::update(const Route& route, double la
     if (!weak) {
         const float edgeMargin = std::max(tuning.edgeMarginM, 0.3f * acc);
         // Near the start the route was snapped from one position: only the distance counts there
-        const bool pastStart = progress > tuning.startGuardM;
-        if (distance > off) {
+        const bool pastStart = progress > tuning.startGuardM && !coarse;
+        if (distance > offHere) {
             rule = OffRouteRule::Distance;
         } else if (pastStart && std::isfinite(current.headingDifference) && std::isfinite(speedMps) && speedMps > tuning.headingSpeed &&
             current.headingDifference > tuning.headingDegrees && distance > tuning.headingShare * off) {
@@ -384,7 +397,7 @@ const RouteFollower::Status& RouteFollower::update(const Route& route, double la
 
     // Weak GPS only stops the off-route rule: a fix further than the match limit (accuracy + MATCH_METRES), beyond the
     // goal say, moves neither the progress nor makes an arrival
-    if (rule == OffRouteRule::None && distance <= matchLimit) {
+    if (rule == OffRouteRule::None && distance <= matchLimitHere) {
         // On the route (in weak GPS too, followed by projection)
         lastSegment = segment;
         current.progressM = progress;
@@ -399,6 +412,10 @@ const RouteFollower::Status& RouteFollower::update(const Route& route, double la
         } else if (current.state != State::OffRoute) {
             current.state = State::Away;
         }
+    } else if (current.state == State::OffRoute) {
+        // Weak GPS (or settling) with a fix beyond the match limit: nothing says off route any more, so the state must
+        // not keep asking for a new route. The progress stays where it was.
+        current.state = State::Away;
     }
     // Arrival: close to the goal, or the end of the route reached on it
     const RoutePoint& goal = route.points[route.points.size() - 1];
diff --git a/Apps/Maps/main/Source/route/RouteFollower.h b/Apps/Maps/main/Source/route/RouteFollower.h
index 9f19731..d4f41f8 100644
--- a/Apps/Maps/main/Source/route/RouteFollower.h
+++ b/Apps/Maps/main/Source/route/RouteFollower.h
@@ -34,6 +34,9 @@ const char* turnPhrase(Turn turn);
  * the route by edgeMarginM while farther than edgeShare * off. triggerFixes away fixes in a row are off route. Above
  * weakAccuracyM nothing triggers ("Weak GPS"). The values can be changed by the "offroute" debug command.
  */
+/** Added to the off-route distance on steps of the main-road layer (ROUTE_STEP_COARSE). */
+constexpr float COARSE_EXTRA_M = 45.0f;
+
 struct OffRouteTuning {
     float accuracyFactor = 1.5f;
     float accuracyAddM = 5.0f;
@@ -60,7 +63,7 @@ struct OffRouteTuning {
     /** The edge rule only with GPS this good: with poor GPS the noise alone puts fixes nearer to side streets. */
     float edgeMaxAccuracyM = 10.0f;
     /** At least this long between two recalculations after the first one. */
-    uint32_t recalculateMs = 10000;
+    uint32_t recalculateMs = 0;   // not used by the app since 0.6.0: a new route is asked for at once
     /** Fixes not checked after a new route, so it settles. */
     int settleFixes = 2;
     /** The heading and edge rules count only past this many metres along a route (device replays: false alarms at the start). */
diff --git a/Apps/Maps/main/Source/route/RouteGraph.cpp b/Apps/Maps/main/Source/route/RouteGraph.cpp
index 825f448..54253c2 100644
--- a/Apps/Maps/main/Source/route/RouteGraph.cpp
+++ b/Apps/Maps/main/Source/route/RouteGraph.cpp
@@ -276,10 +276,17 @@ void GraphBuilder::clipAndAdd() {
     }
 }
 
+/** The sides of the GRAPH_ZOOM tiles inside a tile of the main-road layer, in its units. */
+constexpr int LAYER_GRID = GRAPH_EXTENT >> (GRAPH_ZOOM - GRAPH_MAIN_ZOOM);
+
 void GraphBuilder::addPart(const Point* points, size_t count) {
     // Half-open ownership: a segment lying on the x = 4096 or y = 4096 side belongs to the neighbour tile
     size_t start = 0;
     for (size_t i = 0; i + 1 <= count; i++) {
+        if (wayPoints.failed() || ways.failed()) {
+            // Out of memory: the build fails (finish() checks), nothing more is added
+            return;
+        }
         const bool last = i + 1 == count;
         const bool onFar = !last && ((points[i].x == GRAPH_EXTENT && points[i + 1].x == GRAPH_EXTENT) ||
             (points[i].y == GRAPH_EXTENT && points[i + 1].y == GRAPH_EXTENT));
@@ -290,10 +297,47 @@ void GraphBuilder::addPart(const Point* points, size_t count) {
         if (end - start >= 2) {
             Way way = current;
             way.first = static_cast<uint32_t>(wayPoints.size());
-            way.count = static_cast<uint32_t>(end - start);
-            for (size_t j = start; j < end; j++) {
-                wayPoints.push(points[j]);
+            if (tile.z == GRAPH_MAIN_ZOOM) {
+                // The main-road layer gets a point wherever a road crosses a side of a GRAPH_ZOOM tile (makeNodes()
+                // makes it a node): there the local graphs have their border nodes, so the two levels can be joined
+                // on every main road every tile, not only at the junctions of two main roads (a village on one
+                // road through a valley has none for many kilometres)
+                wayPoints.push(points[start]);
+                for (size_t j = start + 1; j < end && !wayPoints.failed(); j++) {
+                    const Point a = points[j - 1];
+                    const Point b = points[j];
+                    float crossings[40];
+                    int crossingCount = 0;
+                    for (int axis = 0; axis < 2; axis++) {
+                        const int from = axis == 0 ? a.x : a.y;
+                        const int to = axis == 0 ? b.x : b.y;
+                        if (from == to) {
+                            continue;
+                        }
+                        const int low = std::min(from, to);
+                        const int high = std::max(from, to);
+                        for (int line = (low / LAYER_GRID + 1) * LAYER_GRID; line < high && crossingCount < 40; line += LAYER_GRID) {
+                            crossings[crossingCount++] = static_cast<float>(line - from) / static_cast<float>(to - from);
+                        }
+                    }
+                    std::sort(crossings, crossings + crossingCount);
+                    for (int k = 0; k < crossingCount; k++) {
+                        const float t = crossings[k];
+                        const Point at { static_cast<int16_t>(roundUnit(a.x + t * (b.x - a.x))), static_cast<int16_t>(roundUnit(a.y + t * (b.y - a.y))) };
+                        // (never empty here: the loop stops once a push has failed)
+                        const Point previous = wayPoints[wayPoints.size() - 1];
+                        if ((at.x != previous.x || at.y != previous.y) && (at.x != b.x || at.y != b.y)) {
+                            wayPoints.push(at);
+                        }
+                    }
+                    wayPoints.push(b);
+                }
+            } else {
+                for (size_t j = start; j < end; j++) {
+                    wayPoints.push(points[j]);
+                }
             }
+            way.count = static_cast<uint32_t>(wayPoints.size() - way.first);
             ways.push(way);
             counters.points += way.count;
         }
@@ -583,7 +627,9 @@ bool GraphBuilder::makeNodes() {
             const uint32_t point = way.first + j;
             if (nodeOf[point] != UINT32_MAX) {
                 since = 0;
-            } else if (++since >= MAX_SHAPE_POINTS) {
+            } else if (++since >= MAX_SHAPE_POINTS ||
+                (tile.z == GRAPH_MAIN_ZOOM && (wayPoints[point].x % LAYER_GRID == 0 || wayPoints[point].y % LAYER_GRID == 0))) {
+                // (on the layer also every point on a side of a GRAPH_ZOOM tile, see addPart())
                 const Point p = wayPoints[point];
                 nodeOf[point] = static_cast<uint32_t>(nodes.size());
                 nodes.push({ static_cast<uint16_t>(p.x), static_cast<uint16_t>(p.y), way.level });
diff --git a/Apps/Maps/main/Source/route/RouteSearch.cpp b/Apps/Maps/main/Source/route/RouteSearch.cpp
index e1552b4..3c0b6c9 100644
--- a/Apps/Maps/main/Source/route/RouteSearch.cpp
+++ b/Apps/Maps/main/Source/route/RouteSearch.cpp
@@ -14,6 +14,25 @@ namespace {
 constexpr uint32_t EMPTY = 0xFFFFFFFFu;
 constexpr uint32_t NO_PARENT = 0xFFFFFFFEu;
 constexpr int MAX_TILES = 160;
+/** A car route longer than this in a straight line first tries the larger roads only between its ends (find()). */
+constexpr float MAIN_ROADS_FROM_M = 5000.0f;
+/** How far a start or goal may be from a road of the main-road layer when no local road is near (snap()). */
+constexpr float LAYER_SNAP_M = 1500.0f;
+/** Around the start and the goal every road counts, this far. */
+constexpr float MAIN_ROADS_REACH_M = 2000.0f;
+/**
+ * The main-road layer (M5c-5): the graphs of z10 tiles hold the motorways to secondary roads of 16 times the ground
+ * of a z14 tile. A route longer than LAYER_FROM_M in a straight line is searched on two levels: the local roads
+ * (z14 graphs) within LAYER_REACH_M of the start and the goal, the main-road layer everywhere, joined where a
+ * junction of the layer lies on a main road of the local graph (within LINK_M).
+ */
+constexpr float LAYER_FROM_M = 20000.0f;
+constexpr float LAYER_REACH_M = 4000.0f;
+constexpr float LINK_M = 60.0f;
+/** z14 units per unit of a tile of a zoom. */
+int unitsOf(const TileKey& tile) {
+    return 1 << (GRAPH_ZOOM - tile.z);
+}
 /** A road piece of fewer nodes that touches no tile side is an island, never snapped to (see isIsland()). */
 constexpr int ISLAND_NODES = 40;
 /** A start or goal whose roads reach fewer nodes than this, over tile sides too, moves to a road outside them. */
@@ -27,6 +46,8 @@ constexpr double WORLD_UNITS = 16384.0 * GRAPH_EXTENT;
 constexpr uint8_t VIA_BACKWARDS = 1;
 constexpr uint8_t VIA_JOIN = 2;
 constexpr uint8_t VIA_START = 4;
+/** Between a local road's node and the main-road layer's node at the same junction (no edge, a few metres). */
+constexpr uint8_t VIA_LINK = 8;
 
 uint16_t readU16(const uint8_t* bytes) {
     return static_cast<uint16_t>(bytes[0] | (bytes[1] << 8));
@@ -164,6 +185,8 @@ const char* routeResultText(RouteResult result) {
             return "Not enough memory for a route now; try again";
         case RouteResult::Cancelled:
             return "Route search stopped";
+        case RouteResult::NoTrack:
+            return "No track or route in this GPX file";
     }
     return "";
 }
@@ -176,6 +199,7 @@ void Route::clear() {
     sides.clear();
     lengthM = 0.0f;
     seconds = 0.0f;
+    track = false;
 }
 
 const char* Route::stepName(const RouteStep& step, char* out, size_t size) const {
@@ -210,6 +234,8 @@ struct RouteSearch::Tile {
     uint8_t* flags;
     uint16_t* border[4];
     uint32_t borderCount[4];
+    /** 1 for nodes on a road of the main classes (motorway to secondary): where the layers meet. */
+    uint8_t* mainNode;
 };
 
 RouteSearch::~RouteSearch() {
@@ -269,7 +295,7 @@ bool RouteSearch::loadTile(GraphSource& source, const TileKey& tile, Tile& out)
     out.key = tile;
     out.missing = true;
     const uint32_t start = nowMs();
-    const bool read = source.readGraph(tile, fileBuffer);
+    const bool read = readTileFile(source, tile);
     loadMs += nowMs() - start;
     GraphHeader header {};
     if (!read || !readGraphHeader(fileBuffer.begin(), fileBuffer.size(), header) || header.version != GRAPH_FORMAT_VERSION ||
@@ -288,6 +314,7 @@ bool RouteSearch::loadTile(GraphSource& source, const TileKey& tile, Tile& out)
         // Only nodes and edges are needed: the shapes and names are read again for the route that is found
         const size_t wanted = header.nodeCount * GRAPH_NODE_BYTES + header.edgeCount * GRAPH_EDGE_BYTES;
         if (!bodyBuffer.resize(wanted)) {
+            allocationFailed = true;
             return false;
         }
         MemoryInput input(body, header.storedSize);
@@ -300,12 +327,13 @@ bool RouteSearch::loadTile(GraphSource& source, const TileKey& tile, Tile& out)
     const uint32_t n = header.nodeCount;
     const uint32_t e = header.edgeCount;
     // One block: x, y, first (u32, aligned first), adjacency, edge fields, levels, classes, flags, borders
-    const size_t bytes = n * 4u + (n + 1) * 4u + e * 4u + e * 6u + n + e * 2u + n * 2u * 2u + 64;
+    const size_t bytes = n * 4u + (n + 1) * 4u + e * 4u + e * 6u + n + e * 2u + n * 2u * 2u + n + 64;
     if (graphBytes + bytes > budget || source.memoryShort()) {
         return false;
     }
     auto* block = static_cast<uint8_t*>(largeAlloc(bytes));
     if (block == nullptr) {
+        allocationFailed = true;
         return false;
     }
     uint8_t* cursor = block;
@@ -324,6 +352,8 @@ bool RouteSearch::loadTile(GraphSource& source, const TileKey& tile, Tile& out)
     out.level = take(n);
     out.roadClass = take(e);
     out.flags = take(e);
+    out.mainNode = take(n);
+    memset(out.mainNode, 0, n);
     out.block = block;
     out.bytes = bytes;
     out.nodeCount = n;
@@ -354,6 +384,10 @@ bool RouteSearch::loadTile(GraphSource& source, const TileKey& tile, Tile& out)
         }
         out.first[out.from[i] + 1]++;
         out.first[out.to[i] + 1]++;
+        if (out.roadClass[i] <= static_cast<uint8_t>(RoadClass::Secondary)) {
+            out.mainNode[out.from[i]] = 1;
+            out.mainNode[out.to[i]] = 1;
+        }
     }
     for (uint32_t i = 1; i <= n; i++) {
         out.first[i] += out.first[i - 1];
@@ -405,8 +439,8 @@ int RouteSearch::tileSlot(GraphSource& source, const TileKey& tile) {
     }
     if (!loadTile(source, tile, tiles[tileCount])) {
         // Over the budget: the tile counts as missing (never read again), the search goes on around it. Short of
-        // memory on the device: the search ends
-        if (source.memoryShort()) {
+        // memory on the device, or no memory for the tile: the search ends
+        if (allocationFailed || source.memoryShort()) {
             tilesFull = true;
             return -2;
         }
@@ -494,7 +528,45 @@ bool RouteSearch::pop(QueueItem& out) {
 RoutePoint RouteSearch::globalOf(uint32_t key) const {
     const Tile& tile = tiles[slotOf(key)];
     const uint16_t node = nodeOfKey(key);
-    return { tile.key.x * GRAPH_EXTENT + tile.nodeX[node], tile.key.y * GRAPH_EXTENT + tile.nodeY[node] };
+    const int units = unitsOf(tile.key);
+    return { (tile.key.x * GRAPH_EXTENT + tile.nodeX[node]) * units, (tile.key.y * GRAPH_EXTENT + tile.nodeY[node]) * units };
+}
+
+bool RouteSearch::linkAcross(GraphSource& source, const RoutePoint& at, uint8_t level, int toZoom, uint32_t& linked, bool& limit) {
+    // The tile of the other level that holds the point, and its nearest main-road node within LINK_M
+    const int units = 1 << (GRAPH_ZOOM - toZoom);
+    const TileKey key { toZoom, at.x / (GRAPH_EXTENT * units), at.y / (GRAPH_EXTENT * units) };
+    const int slot = tileSlot(source, key);
+    if (slot == -2) {
+        limit = true;
+        return false;
+    }
+    if (slot < 0) {
+        return false;
+    }
+    const Tile& tile = tiles[slot];
+    const float reach = LINK_M / static_cast<float>(routeMetresPerUnit(at.y));
+    float best = reach * reach;
+    int bestNode = -1;
+    const float localX = static_cast<float>(at.x) / units - static_cast<float>(key.x) * GRAPH_EXTENT;
+    const float localY = static_cast<float>(at.y) / units - static_cast<float>(key.y) * GRAPH_EXTENT;
+    for (uint32_t i = 0; i < tile.nodeCount; i++) {
+        if (tile.mainNode[i] == 0 || tile.level[i] != level) {
+            continue;
+        }
+        const float dx = (tile.nodeX[i] - localX) * units;
+        const float dy = (tile.nodeY[i] - localY) * units;
+        const float squared = dx * dx + dy * dy;
+        if (squared < best) {
+            best = squared;
+            bestNode = static_cast<int>(i);
+        }
+    }
+    if (bestNode < 0) {
+        return false;
+    }
+    linked = keyOf(slot, static_cast<uint32_t>(bestNode));
+    return true;
 }
 
 bool RouteSearch::joinAcross(GraphSource& source, int slot, uint16_t node, int side, uint32_t& joined, bool& limit) {
@@ -507,7 +579,7 @@ bool RouteSearch::joinAcross(GraphSource& source, int slot, uint16_t node, int s
     }
     const uint8_t level = tile->level[node];
     const TileKey here = tile->key;
-    const TileKey next { GRAPH_ZOOM, here.x + (side == 0 ? -1 : (side == 2 ? 1 : 0)), here.y + (side == 1 ? -1 : (side == 3 ? 1 : 0)) };
+    const TileKey next { here.z, here.x + (side == 0 ? -1 : (side == 2 ? 1 : 0)), here.y + (side == 1 ? -1 : (side == 3 ? 1 : 0)) };
     const int nextSlot = tileSlot(source, next);
     if (nextSlot == -2) {
         limit = true;
@@ -667,11 +739,24 @@ bool RouteSearch::isIsland(const Tile& tile, uint16_t edge, RouteProfile islandP
     return true;
 }
 
-bool RouteSearch::snap(GraphSource& source, const RoutePoint& point, RouteProfile snapProfile, Snap& out) {
-    // The tile of the point and the neighbours within reach
+bool RouteSearch::readTileFile(GraphSource& source, const TileKey& tile) {
+    if (fileBufferValid && fileBufferTile == tile) {
+        return true;
+    }
+    fileBufferValid = source.readGraph(tile, fileBuffer);
+    fileBufferTile = tile;
+    return fileBufferValid;
+}
+
+bool RouteSearch::snap(GraphSource& source, const RoutePoint& point, RouteProfile snapProfile, Snap& out, int zoom) {
+    // The tile of the point and the neighbours within reach. `point` and `reach` are in the units of GRAPH_ZOOM;
+    // a tile of the main-road layer is `units` times as large, its own coordinates as many times coarser
+    const int units = 1 << (GRAPH_ZOOM - zoom);
+    const int32_t extent = GRAPH_EXTENT * units;
     const double metresPerUnit = routeMetresPerUnit(point.y);
+    const float metresPerLocal = static_cast<float>(metresPerUnit) * static_cast<float>(units);
     // A car may stop further from a destination off the roads (a park, a forest): the rest is on foot
-    const float radius = snapProfile == RouteProfile::Car ? CAR_SNAP_METRES : SNAP_METRES;
+    const float radius = zoom != GRAPH_ZOOM ? LAYER_SNAP_M : (snapProfile == RouteProfile::Car ? CAR_SNAP_METRES : SNAP_METRES);
     const auto reach = static_cast<int32_t>(radius / metresPerUnit) + 1;
     float best = radius;
     bool found = false;
@@ -680,23 +765,42 @@ bool RouteSearch::snap(GraphSource& source, const RoutePoint& point, RouteProfil
     bool island = false;
     TileGraph graph;
     ShapeBuffer shape;
-    const int left = (point.x - reach) / GRAPH_EXTENT;
-    const int right = (point.x + reach) / GRAPH_EXTENT;
-    const int top = (point.y - reach) / GRAPH_EXTENT;
-    const int bottom = (point.y + reach) / GRAPH_EXTENT;
-    for (int ty = top; ty <= bottom; ty++) {
-        for (int tx = left; tx <= right; tx++) {
-            const TileKey key { GRAPH_ZOOM, tx, ty };
+    const int left = (point.x - reach) / extent;
+    const int right = (point.x + reach) / extent;
+    const int top = (point.y - reach) / extent;
+    const int bottom = (point.y + reach) / extent;
+    // The point's own tile first, then the others: a tile further away than the nearest road found so far is not
+    // read at all (with a road next to the point that is one tile instead of four)
+    const int ownX = point.x / extent;
+    const int ownY = point.y / extent;
+    const int columns = right - left + 1;
+    const int count = columns * (bottom - top + 1);
+    for (int index = -1; index < count; index++) {
+        const int tx = index < 0 ? ownX : left + index % columns;
+        const int ty = index < 0 ? ownY : top + index / columns;
+        if (index >= 0 && tx == ownX && ty == ownY) {
+            continue;
+        }
+        {
+            // The nearest point of the tile's square to the point, in metres
+            const int32_t nearX = std::clamp<int32_t>(point.x, tx * extent, (tx + 1) * extent);
+            const int32_t nearY = std::clamp<int32_t>(point.y, ty * extent, (ty + 1) * extent);
+            const float gapX = static_cast<float>(point.x - nearX);
+            const float gapY = static_cast<float>(point.y - nearY);
+            if (std::sqrt(gapX * gapX + gapY * gapY) * static_cast<float>(metresPerUnit) >= best) {
+                continue;
+            }
+            const TileKey key { zoom, tx, ty };
             const int slot = tileSlot(source, key);
-            if (slot < 0 || !source.readGraph(key, fileBuffer)) {
+            if (slot < 0 || !readTileFile(source, key)) {
                 continue;
             }
             // The full graph with shapes, for this tile only
             if (!loadTileGraph(fileBuffer.begin(), fileBuffer.size(), inflater, graph)) {
                 continue;
             }
-            const int32_t px = point.x - tx * GRAPH_EXTENT;
-            const int32_t py = point.y - ty * GRAPH_EXTENT;
+            const float px = static_cast<float>(point.x - tx * extent) / static_cast<float>(units);
+            const float py = static_cast<float>(point.y - ty * extent) / static_cast<float>(units);
             for (uint32_t e = 0; e < graph.edges.size(); e++) {
                 const GraphEdge& edge = graph.edges[e];
                 if (!routeAllows(snapProfile, edge.roadClass, edge.flags)) {
@@ -713,7 +817,7 @@ bool RouteSearch::snap(GraphSource& source, const RoutePoint& point, RouteProfil
                     t = std::clamp(t, 0.0f, 1.0f);
                     const float qx = ax + t * dx;
                     const float qy = ay + t * dy;
-                    const float distance = std::sqrt((px - qx) * (px - qx) + (py - qy) * (py - qy)) * static_cast<float>(metresPerUnit);
+                    const float distance = std::sqrt((px - qx) * (px - qx) + (py - qy) * (py - qy)) * metresPerLocal;
                     if (distance < best && excludeSeen &&
                         (entry(keyOf(slot, tiles[slot].from[e]), false) != nullptr || entry(keyOf(slot, tiles[slot].to[e]), false) != nullptr)) {
                         // In the small piece of road found before (snapOutside)
@@ -736,7 +840,8 @@ bool RouteSearch::snap(GraphSource& source, const RoutePoint& point, RouteProfil
                         out.along = shape.at[i - 1] + t * (shape.at[i] - shape.at[i - 1]);
                         out.total = shape.total();
                         out.distanceM = distance;
-                        out.point = { tx * GRAPH_EXTENT + static_cast<int32_t>(std::floor(qx + 0.5f)), ty * GRAPH_EXTENT + static_cast<int32_t>(std::floor(qy + 0.5f)) };
+                        out.point = { tx * extent + static_cast<int32_t>(std::floor(qx * static_cast<float>(units) + 0.5f)),
+                            ty * extent + static_cast<int32_t>(std::floor(qy * static_cast<float>(units) + 0.5f)) };
                     }
                 }
             }
@@ -774,6 +879,7 @@ RouteResult RouteSearch::find(GraphSource& source, double fromLat, double fromLo
     counters.passes = 1;
     loadMs = 0;
     cancelled = false;
+    fileBufferValid = false;
     profile = searchProfile;
     if (table == nullptr) {
         return RouteResult::NoMemory;
@@ -781,6 +887,7 @@ RouteResult RouteSearch::find(GraphSource& source, double fromLat, double fromLo
     release();
     tilesFull = false;
     budgetHit = false;
+    allocationFailed = false;
     peakGraphBytes = 0;
     resetStates();
     const RoutePoint from = routePointFrom(fromLat, fromLon);
@@ -800,7 +907,8 @@ RouteResult RouteSearch::find(GraphSource& source, double fromLat, double fromLo
     };
     Snap start {};
     Snap goal {};
-    // Seconds per unit of straight distance at the fastest speed: never more than the real time, so A* stays exact
+    // Seconds per unit of straight distance at the fastest speed. For walking and cycling never more than the real time,
+    // so A* stays exact; for the car it deliberately is not (CAR_ESTIMATE_KMH), see routeMaxKmh()
     const float metresPerUnit = static_cast<float>(std::min(routeMetresPerUnit(from.y), routeMetresPerUnit(to.y))) * 0.995f;
     const float scale = metresPerUnit * 3.6f / routeMaxKmh(profile);
 
@@ -814,34 +922,117 @@ RouteResult RouteSearch::find(GraphSource& source, double fromLat, double fromLo
     // goal and settles and reads far fewer. The route may be a little longer than the best one (at most RETRY_WEIGHT
     // times, a few percent in practice), which beats "too long" for a city trip. Out of graph memory, the tiles are
     // read again from the start; out of node states, the tiles read stay.
-    for (int pass = 0; pass < 2; pass++) {
-        const float weighted = pass == 0 ? scale : scale * RETRY_WEIGHT;
-        // Out of tile memory (the budget, or the device's free memory, tilesFull): the tiles go and are read again
-        const bool readAgain = pass > 0 && (budgetHit || tilesFull);
-        if (pass > 0) {
+    //
+    // Before both, for a car going further than MAIN_ROADS_FROM_M: a pass that takes only the larger roads
+    // (tertiary and up) where it is further than MAIN_ROADS_REACH_M from both ends, as a driver would. It settles a
+    // fraction of the nodes (the residential and service streets of everything in between stay out), so a route
+    // across a city fits the node states. When it finds no way (a village joined only by small roads) the passes
+    // without that limit follow.
+    //
+    // And for routes longer than LAYER_FROM_M, before all of them, the two-level pass on the main-road layer (see
+    // LAYER_FROM_M); shorter routes take it last, when nothing else found a way (too long for the node states, or
+    // no local roads between two downloaded towns).
+    const float straightM = lengthOf(to.x - from.x, to.y - from.y) * metresPerUnit;
+    counters.straightM = static_cast<uint32_t>(straightM);
+    const bool mainRoads = profile == RouteProfile::Car && straightM > MAIN_ROADS_FROM_M;
+    // LayeredWeighted: the two-level pass again, goal-directed, when the first ran out of node states (a route
+    // across the country)
+    enum class Pass : uint8_t { Layered, LayeredWeighted, MainRoads, Exact, Weighted };
+    Pass plan[6];
+    int passes = 0;
+    const bool layerFirst = straightM > LAYER_FROM_M;
+    // Around a walker or a cyclist far more roads count than around a car (a city's footways within 4 km are more
+    // nodes than the states hold), and they join a main road sooner
+    const float layerReachM = profile == RouteProfile::Car ? LAYER_REACH_M : (profile == RouteProfile::Bike ? 2500.0f : 1500.0f);
+    if (layerFirst) {
+        // Beyond this distance the passes on local roads alone cannot end well: only the goal-directed one is
+        // tried after the layer, which costs the least
+        plan[passes++] = Pass::Layered;
+        plan[passes++] = Pass::LayeredWeighted;
+        // Up to twice that distance the local roads may still do it where the layer's tiles are missing (one large
+        // detailed region). Further never: on the T-Deck that pass read 121 tiles of the start's city for 47 s
+        // before it gave up on a route of 270 km with no main roads on the card (15 Nov)
+        if (straightM <= 2.0f * LAYER_FROM_M) {
+            plan[passes++] = Pass::Weighted;
+        }
+    } else {
+        if (mainRoads) {
+            plan[passes++] = Pass::MainRoads;
+        }
+        plan[passes++] = Pass::Exact;
+        plan[passes++] = Pass::Weighted;
+        if (straightM > 2.0f * layerReachM) {
+            plan[passes++] = Pass::Layered;
+            plan[passes++] = Pass::LayeredWeighted;
+        }
+    }
+    bool anyLimit = false;
+    for (int step = 0; step < passes; step++) {
+        Pass kind = plan[step];
+        bool restricted = kind == Pass::MainRoads;
+        bool layered = kind == Pass::Layered || kind == Pass::LayeredWeighted;
+        float reachUnits = (layered ? layerReachM : MAIN_ROADS_REACH_M) / metresPerUnit;
+        const bool again = step > 0;
+        float weighted = kind == Pass::Weighted || kind == Pass::LayeredWeighted ? scale * RETRY_WEIGHT : scale;
+        // Out of tile memory (the budget, or the device's free memory, tilesFull): the tiles go and are read again.
+        // The layered pass starts with all the memory in any case
+        const bool readAgain = again && (budgetHit || tilesFull || kind == Pass::Layered);
+        if (again) {
+            anyLimit = anyLimit || limit || budgetHit;
             if (readAgain) {
                 release();
                 budgetHit = false;
             }
             resetStates();
             tilesFull = false;
-            counters.passes = 2;
+            allocationFailed = false;
             best = INFINITY;
             last = EMPTY;
             lastSide = 0;
             direct = false;
             limit = false;
         }
-        if (pass == 0 || readAgain) {
+        counters.passes = kind == Pass::Weighted || kind == Pass::LayeredWeighted ? 2 : 1;
+        counters.layered = layered;
+        if (!again || readAgain) {
             // A tile near the start or goal that did not fit in the memory is no missing road
+            // No local road near (no map of the place on the card, between two downloaded towns): the nearest road of
+            // the main-road layer, which is there for the whole downloaded country
             if (!snap(source, from, profile, start)) {
-                return finish(budgetHit || tilesFull ? RouteResult::NoMemory : RouteResult::NoRoadNearStart);
+                if (budgetHit || tilesFull) {
+                    return finish(RouteResult::NoMemory);
+                }
+                if (!snap(source, from, profile, start, GRAPH_MAIN_ZOOM)) {
+                    return finish(budgetHit || tilesFull ? RouteResult::NoMemory : RouteResult::NoRoadNearStart);
+                }
             }
             if (!snap(source, to, profile, goal)) {
-                return finish(budgetHit || tilesFull ? RouteResult::NoMemory : RouteResult::NoRoadNearGoal);
+                if (budgetHit || tilesFull) {
+                    return finish(RouteResult::NoMemory);
+                }
+                if (!snap(source, to, profile, goal, GRAPH_MAIN_ZOOM)) {
+                    return finish(budgetHit || tilesFull ? RouteResult::NoMemory : RouteResult::NoRoadNearGoal);
+                }
             }
-            snapOutside(source, from, profile, false, start);
-            snapOutside(source, to, profile, true, goal);
+            if (tiles[start.slot].key.z == GRAPH_ZOOM) {
+                snapOutside(source, from, profile, false, start);
+            }
+            if (tiles[goal.slot].key.z == GRAPH_ZOOM) {
+                snapOutside(source, to, profile, true, goal);
+            }
+        }
+        if (!layered && (tiles[start.slot].key.z != GRAPH_ZOOM || tiles[goal.slot].key.z != GRAPH_ZOOM)) {
+            // An end on the layer: only the two-level search leads there, so this pass is one, and only its
+            // goal-directed twin follows
+            kind = Pass::Layered;
+            layered = true;
+            restricted = false;
+            reachUnits = layerReachM / metresPerUnit;
+            weighted = scale;
+            counters.passes = 1;
+            counters.layered = true;
+            plan[step + 1] = Pass::LayeredWeighted;
+            passes = step + 2;
         }
         const RoutePoint goalPoint = goal.point;
         const Tile& startTile = tiles[start.slot];
@@ -899,10 +1090,45 @@ RouteResult RouteSearch::find(GraphSource& source, double fromLat, double fromLo
             const uint16_t node = nodeOfKey(item.key);
             // Copies: loading a neighbour below may not move the tiles, but keeps the code clear of that question
             const Tile* tile = &tiles[slot];
+            bool mainOnly = false;
+            if (restricted || layered) {
+                const RoutePoint here = globalOf(item.key);
+                const bool nearStart = lengthOf(here.x - from.x, here.y - from.y) <= reachUnits;
+                const bool nearGoal = lengthOf(here.x - to.x, here.y - to.y) <= reachUnits;
+                mainOnly = !nearStart && !nearGoal;
+                if (layered) {
+                    const bool local = tile->key.z == GRAPH_ZOOM;
+                    // Up from a main road's junction to the layer anywhere the local roads are searched, down from the
+                    // layer to the local roads near the goal only (near the start it would only go round in circles)
+                    if (tile->mainNode[node] != 0 && (local || nearGoal)) {
+                        uint32_t linked = EMPTY;
+                        if (linkAcross(source, here, tile->level[node], local ? GRAPH_MAIN_ZOOM : GRAPH_ZOOM, linked, limit)) {
+                            // tile may be a neighbour's now for nothing: linkAcross only adds tiles
+                            const RoutePoint there = globalOf(linked);
+                            const float metres = lengthOf(there.x - here.x, there.y - here.y) * metresPerUnit;
+                            relax(linked, g + routeSeconds(profile, static_cast<uint8_t>(RoadClass::Secondary), metres), item.key, 0, VIA_LINK,
+                                goalPoint, weighted);
+                        }
+                    }
+                    if (local && mainOnly) {
+                        // Local roads far from both ends are not searched at all: that is the layer's part
+                        if (used >= maxNodes || tilesFull) {
+                            limit = true;
+                            break;
+                        }
+                        continue;
+                    }
+                    // On the layer every road is a main road
+                    mainOnly = false;
+                }
+            }
             for (uint32_t k = tile->first[node]; k < tile->first[node + 1]; k++) {
                 const uint16_t entryValue = tile->adjacent[k];
                 const uint16_t edge = static_cast<uint16_t>(entryValue >> 1);
                 const bool backwards = (entryValue & 1) != 0;
+                if (mainOnly && tile->roadClass[edge] > static_cast<uint8_t>(RoadClass::Tertiary)) {
+                    continue;
+                }
                 if (!routeAllows(profile, tile->roadClass[edge], tile->flags[edge]) || (backwards && !routeAllowsBackwards(profile, tile->flags[edge]))) {
                     continue;
                 }
@@ -922,12 +1148,20 @@ RouteResult RouteSearch::find(GraphSource& source, double fromLat, double fromLo
                 break;
             }
         }
-        if (best != INFINITY || !(limit || budgetHit)) {
+        if (best != INFINITY) {
             break;
         }
+        // The exact pass ended without running out of anything: the goal-directed one would find no way either
+        if (!(limit || budgetHit) && step + 1 < passes &&
+            ((kind == Pass::Exact && plan[step + 1] == Pass::Weighted) || (kind == Pass::Layered && plan[step + 1] == Pass::LayeredWeighted))) {
+            step++;
+        }
     }
     if (best == INFINITY) {
-        return finish(limit || budgetHit ? RouteResult::TooLong : RouteResult::NoPath);
+        if (allocationFailed) {
+            return finish(RouteResult::NoMemory);
+        }
+        return finish(anyLimit || limit || budgetHit ? RouteResult::TooLong : RouteResult::NoPath);
     }
     route.seconds = best;
     if (!assemble(source, start, goal, last, lastSide, direct, route)) {
@@ -973,14 +1207,15 @@ bool RouteSearch::assemble(GraphSource& source, const Snap& start, const Snap& g
             return true;
         }
         graphTile = { -1, -1, -1 };
-        if (!source.readGraph(tile, fileBuffer) || !loadTileGraph(fileBuffer.begin(), fileBuffer.size(), inflater, graph)) {
+        if (!readTileFile(source, tile) || !loadTileGraph(fileBuffer.begin(), fileBuffer.size(), inflater, graph)) {
             return false;
         }
         graphTile = tile;
         return true;
     };
     auto addPoint = [&](const TileKey& tile, int32_t x, int32_t y) {
-        const RoutePoint point { tile.x * GRAPH_EXTENT + x, tile.y * GRAPH_EXTENT + y };
+        const int units = unitsOf(tile);
+        const RoutePoint point { (tile.x * GRAPH_EXTENT + x) * units, (tile.y * GRAPH_EXTENT + y) * units };
         if (route.points.size() > 0) {
             const RoutePoint& previous = route.points[route.points.size() - 1];
             if (previous.x == point.x && previous.y == point.y) {
@@ -997,6 +1232,7 @@ bool RouteSearch::assemble(GraphSource& source, const Snap& start, const Snap& g
         if (route.steps.size() > 0) {
             const RouteStep& previous = route.steps[route.steps.size() - 1];
             if (previous.roadClass == e.roadClass && previous.nameLength == length &&
+                ((previous.flags & ROUTE_STEP_COARSE) != 0) == (graphTile.z == GRAPH_MAIN_ZOOM) &&
                 (length == 0 || memcmp(route.names.begin() + previous.nameOffset, name, length) == 0)) {
                 return;
             }
@@ -1005,7 +1241,9 @@ bool RouteSearch::assemble(GraphSource& source, const Snap& start, const Snap& g
         for (uint8_t i = 0; i < length && route.names.size() < 65000; i++) {
             route.names.push(name[i]);
         }
-        route.steps.push({ pointIndex, offset, length, e.roadClass, e.flags });
+        // A step on the main-road layer: its line is the z10 tile's, simplified more than the map's roads
+        const uint8_t coarse = graphTile.z == GRAPH_MAIN_ZOOM ? ROUTE_STEP_COARSE : 0;
+        route.steps.push({ pointIndex, offset, length, e.roadClass, static_cast<uint8_t>(e.flags | coarse) });
     };
     // Part of an edge's shape from distance d0 to d1 along it (backwards when d0 > d1)
     auto addPart = [&](const TileKey& slot, uint16_t edge, float d0, float d1) {
@@ -1043,7 +1281,7 @@ bool RouteSearch::assemble(GraphSource& source, const Snap& start, const Snap& g
     } else {
         for (size_t i = 0; i < hops.size(); i++) {
             const Hop& hop = hops[i];
-            if ((hop.via & VIA_JOIN) != 0) {
+            if ((hop.via & (VIA_JOIN | VIA_LINK)) != 0) {
                 continue;
             }
             const bool backwards = (hop.via & VIA_BACKWARDS) != 0;
diff --git a/Apps/Maps/main/Source/route/RouteSearch.h b/Apps/Maps/main/Source/route/RouteSearch.h
index 0187444..653d5e2 100644
--- a/Apps/Maps/main/Source/route/RouteSearch.h
+++ b/Apps/Maps/main/Source/route/RouteSearch.h
@@ -24,6 +24,9 @@ void routePointTo(const RoutePoint& point, double& lat, double& lon);
 double routeMetresPerUnit(int32_t y);
 
 /** One stretch of a route on one road: where it starts in the route's points, its name and class. */
+/** In RouteStep::flags (next to the edge's EDGE_ flags): the step runs on the main-road layer, its line is coarse. */
+constexpr uint8_t ROUTE_STEP_COARSE = 128;
+
 struct RouteStep {
     uint32_t point;
     /** Offset into Route::names, the name's length (0: no name). */
@@ -53,6 +56,8 @@ struct Route {
     GrowArray<RouteSide> sides;
     float lengthM = 0.0f;
     float seconds = 0.0f;
+    /** Made from a GPX track (RouteTrack.h), not found by the search: no turns, and off it no new route is searched. */
+    bool track = false;
 
     void clear();
     bool isEmpty() const { return points.size() < 2; }
@@ -70,7 +75,7 @@ class GraphSource {
     virtual bool memoryShort() { return false; }
 };
 
-enum class RouteResult : uint8_t { Found, NoRoadNearStart, NoRoadNearGoal, NoPath, TooLong, NoMemory, Cancelled };
+enum class RouteResult : uint8_t { Found, NoRoadNearStart, NoRoadNearGoal, NoPath, TooLong, NoMemory, Cancelled, NoTrack };
 const char* routeResultText(RouteResult result);
 
 struct RouteStats {
@@ -80,10 +85,14 @@ struct RouteStats {
     uint32_t discovered;
     uint32_t tilesRead;
     uint32_t tilesMissing;
+    /** Metres from start to goal in a straight line. */
+    uint32_t straightM;
     uint32_t peakBytes;
     uint32_t graphBytes;
     /** 2 when the first pass ran out of node states and a second, goal-directed pass ran (see RouteSearch::find). */
     uint32_t passes;
+    /** The route was found on two levels: local roads near both ends, the main-road layer between. */
+    bool layered;
 };
 
 /**
@@ -156,10 +165,23 @@ class RouteSearch {
 
     int tileSlot(GraphSource& source, const TileKey& tile);
     bool loadTile(GraphSource& source, const TileKey& tile, Tile& out);
-    bool snap(GraphSource& source, const RoutePoint& point, RouteProfile profile, Snap& out);
+    /**
+     * Reads a tile's graph file into fileBuffer, unless it is the file that is in there: snapping needs the file of a
+     * tile right after the tile was loaded from it, and every read is 0.5 to 2 s on a busy card.
+     */
+    bool readTileFile(GraphSource& source, const TileKey& tile);
+    /**
+     * `zoom` GRAPH_MAIN_ZOOM: the nearest road of the main-road layer instead (further away, LAYER_SNAP_M), for a
+     * start or goal where no local roads are on the card (between two downloaded towns).
+     */
+    bool snap(GraphSource& source, const RoutePoint& point, RouteProfile profile, Snap& out, int zoom = 14);
     bool isIsland(const Tile& tile, uint16_t edge, RouteProfile islandProfile) const;
     /** The node a tile's node joins across one side; limit when the next tile could not be read. */
     bool joinAcross(GraphSource& source, int slot, uint16_t node, int side, uint32_t& joined, bool& limit);
+    /** The main-road node of the other level (toZoom) at a point; limit when its tile could not be read for memory. */
+    /** level: the source node's (brunnel and layer); only a node on the same level is linked, so a bridge never joins
+     *  the road under it (z10 and z14 tiles carry the same brunnel / layer values). */
+    bool linkAcross(GraphSource& source, const RoutePoint& at, uint8_t level, int toZoom, uint32_t& linked, bool& limit);
     /**
      * Whether the roads around a snapped point reach fewer than COMPONENT_NODES nodes (the states mark them), driving
      * away from it, or towards it for a goal.
@@ -192,7 +214,11 @@ class RouteSearch {
     /** snap() leaves out edges with a state at either end (the small piece found by smallComponent()). */
     bool excludeSeen = false;
     bool budgetHit = false;
+    /** A tile's graph could not be allocated (not the budget): the search is out of memory, not short of roads. */
+    bool allocationFailed = false;
     GrowArray<uint8_t> fileBuffer;
+    TileKey fileBufferTile {};
+    bool fileBufferValid = false;
     GrowArray<uint8_t> bodyBuffer;
     InflateReader inflater;
     bool inflaterReady = false;
diff --git a/Apps/Maps/main/Source/route/RouteSides.cpp b/Apps/Maps/main/Source/route/RouteSides.cpp
index 60bde85..d0e100f 100644
--- a/Apps/Maps/main/Source/route/RouteSides.cpp
+++ b/Apps/Maps/main/Source/route/RouteSides.cpp
@@ -11,6 +11,8 @@ namespace {
 
 /** Route points per chunk; each chunk has a box, so a test looks only at the few chunks nearby. */
 constexpr size_t CHUNK_POINTS = 16;
+/** Tiles whose side roads are worked out, from the start of the route on. */
+constexpr size_t MAX_SIDE_TILES = 120;
 /** A road segment is cut into pieces of at most this many metres before it is tested. */
 constexpr float PIECE_METRES = 15.0f;
 /** A piece this near the route is part of it. */
@@ -105,7 +107,11 @@ bool RouteSearch::addSides(GraphSource& source, const GrowArray<RoutePoint>& poi
                 return;
             }
         }
-        sideTiles.push(key);
+        // A route across a country passes thousands of tiles, most without local roads (its middle is on the
+        // main-road layer): the side roads are for the part near the start, where the route is followed first
+        if (sideTiles.size() < MAX_SIDE_TILES) {
+            sideTiles.push(key);
+        }
     };
     for (size_t i = 0; i < count; i++) {
         const RoutePoint& p = points[i];
diff --git a/Apps/Maps/main/Source/route/RouteSplice.cpp b/Apps/Maps/main/Source/route/RouteSplice.cpp
new file mode 100644
index 0000000..41cab9a
--- /dev/null
+++ b/Apps/Maps/main/Source/route/RouteSplice.cpp
@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "RouteSplice.h"
+
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+
+namespace maps {
+
+namespace {
+
+/** Two route points are the same place: the search's points come from the same tile shapes, a snapped end a little off. */
+bool near(const RoutePoint& a, const RoutePoint& b, int32_t units) {
+    const int64_t dx = static_cast<int64_t>(a.x) - b.x;
+    const int64_t dy = static_cast<int64_t>(a.y) - b.y;
+    return dx * dx + dy * dy <= static_cast<int64_t>(units) * units;
+}
+
+float metresBetween(const RoutePoint& a, const RoutePoint& b) {
+    const float dx = static_cast<float>(b.x - a.x);
+    const float dy = static_cast<float>(b.y - a.y);
+    return std::sqrt(dx * dx + dy * dy) * static_cast<float>(routeMetresPerUnit((a.y + b.y) / 2));
+}
+
+/** Where a snapped end may lie from the point that was asked for: a few metres. */
+constexpr int32_t END_UNITS = 16;
+constexpr int32_t SAME_UNITS = 2;
+
+} // namespace
+
+size_t rejoinTarget(const Route& old, const RoutePoint& position, float progressM, float aheadM, float minLeftM) {
+    const size_t count = old.points.size();
+    if (count < 2 || old.distances.size() != count || old.track) {
+        return SIZE_MAX;
+    }
+    // Level with the position: the nearest point of the route from the progress on
+    float level = progressM;
+    {
+        int64_t best = INT64_MAX;
+        for (size_t i = 0; i < count; i++) {
+            if (old.distances[i] < progressM) {
+                continue;
+            }
+            const int64_t dx = static_cast<int64_t>(old.points[i].x) - position.x;
+            const int64_t dy = static_cast<int64_t>(old.points[i].y) - position.y;
+            const int64_t squared = dx * dx + dy * dy;
+            if (squared < best) {
+                best = squared;
+                level = old.distances[i];
+            }
+        }
+    }
+    const float wanted = level + aheadM;
+    // The distances grow along the route: the first point beyond the wanted one
+    size_t low = 0;
+    size_t high = count - 1;
+    while (low < high) {
+        const size_t middle = (low + high) / 2;
+        if (old.distances[middle] < wanted) {
+            low = middle + 1;
+        } else {
+            high = middle;
+        }
+    }
+    if (old.distances[low] < wanted || old.lengthM - old.distances[low] < minLeftM) {
+        return SIZE_MAX;
+    }
+    return low;
+}
+
+bool rejoinLeadsOn(const RoutePoint& position, const RoutePoint& join, const RoutePoint& destination, float pieceM) {
+    return metresBetween(join, destination) <= metresBetween(position, destination) + pieceM / 3.0f;
+}
+
+bool spliceRoute(const Route& piece, const Route& old, size_t target, Route& out) {
+    out.clear();
+    const size_t pieceCount = piece.points.size();
+    const size_t oldCount = old.points.size();
+    if (pieceCount < 2 || target >= oldCount || !near(piece.points[pieceCount - 1], old.points[target], END_UNITS)) {
+        return false;
+    }
+    // The spur: the piece's last points are the old route's next ones, walked backwards
+    size_t last = pieceCount - 1;
+    size_t join = target;
+    while (last > 0 && join + 1 < oldCount && near(piece.points[last - 1], old.points[join + 1], SAME_UNITS)) {
+        last--;
+        join++;
+    }
+    if (last == 0) {
+        // The whole piece lies on the old route (the position was on it after all): the old route from there
+        last = 0;
+    }
+    // Points: the piece up to the join, the old route after it
+    for (size_t i = 0; i <= last; i++) {
+        out.points.push(piece.points[i]);
+    }
+    for (size_t i = join + 1; i < oldCount; i++) {
+        out.points.push(old.points[i]);
+    }
+    if (out.points.failed() || out.points.size() < 2) {
+        out.clear();
+        return false;
+    }
+    float distance = 0.0f;
+    for (size_t i = 0; i < out.points.size(); i++) {
+        if (i > 0) {
+            distance += metresBetween(out.points[i - 1], out.points[i]);
+        }
+        out.distances.push(distance);
+    }
+    // Steps: the piece's up to the join, then the old route's from the road it is on at the join
+    for (char c : piece.names) {
+        out.names.push(c);
+    }
+    const size_t nameShift = piece.names.size();
+    for (char c : old.names) {
+        out.names.push(c);
+    }
+    if (out.names.size() > UINT16_MAX) {
+        out.clear();
+        return false;
+    }
+    const RouteStep* lastKept = nullptr;
+    for (const RouteStep& step : piece.steps) {
+        if (step.point > last) {
+            break;
+        }
+        out.steps.push(step);
+        lastKept = &step;
+    }
+    const RouteStep* active = nullptr;
+    for (const RouteStep& step : old.steps) {
+        if (step.point <= join) {
+            active = &step;
+        }
+    }
+    auto sameRoad = [&](const RouteStep& a, const RouteStep& b) {
+        // The same coarseness too: a coarse step (main-road layer) keeps its own wider off-route limit
+        return a.roadClass == b.roadClass && (a.flags & ROUTE_STEP_COARSE) == (b.flags & ROUTE_STEP_COARSE) && a.nameLength == b.nameLength &&
+            (a.nameLength == 0 || (a.nameOffset + a.nameLength <= piece.names.size() && b.nameOffset + b.nameLength <= old.names.size() &&
+                memcmp(piece.names.begin() + a.nameOffset, old.names.begin() + b.nameOffset, a.nameLength) == 0));
+    };
+    if (active != nullptr && (lastKept == nullptr || !sameRoad(*lastKept, *active))) {
+        // Another road from the join on: its step starts there
+        RouteStep step = *active;
+        step.point = static_cast<uint32_t>(last);
+        step.nameOffset = static_cast<uint16_t>(step.nameOffset + nameShift);
+        out.steps.push(step);
+    }
+    for (const RouteStep& oldStep : old.steps) {
+        if (oldStep.point <= join) {
+            continue;
+        }
+        RouteStep step = oldStep;
+        step.point = static_cast<uint32_t>(oldStep.point - join + last);
+        step.nameOffset = static_cast<uint16_t>(step.nameOffset + nameShift);
+        out.steps.push(step);
+    }
+    if (out.distances.failed() || out.names.failed() || out.steps.failed()) {
+        out.clear();
+        return false;
+    }
+    out.profile = old.profile;
+    out.track = false;
+    out.from = piece.from;
+    out.to = old.to;
+    out.lengthM = distance;
+    // The time: each part's own speed, by the share of its length that is kept
+    const float pieceKept = out.distances[last];
+    const float oldLeft = old.distances.size() == oldCount ? old.lengthM - old.distances[join] : 0.0f;
+    out.seconds = (piece.lengthM > 0.0f ? piece.seconds * std::min(1.0f, pieceKept / piece.lengthM) : 0.0f) +
+        (old.lengthM > 0.0f ? old.seconds * std::max(0.0f, oldLeft) / old.lengthM : 0.0f);
+    return true;
+}
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/route/RouteSplice.h b/Apps/Maps/main/Source/route/RouteSplice.h
new file mode 100644
index 0000000..24e3c35
--- /dev/null
+++ b/Apps/Maps/main/Source/route/RouteSplice.h
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "RouteSearch.h"
+
+namespace maps {
+
+/**
+ * Off a long route, a new search to the destination takes seconds, and on a bike or a bus the position has moved on
+ * by the time it is done (the new route starts behind, is left again, and so on). So the search goes only as far as
+ * the old route a little ahead, and the rest of the old route is kept (0.6.0).
+ *
+ * The point of the old route to steer for: the first one at least aheadM beyond where the position is along the
+ * route. That is the point of the route nearest to the position from progressM on (not progressM itself: someone
+ * who went on along another road is level with a later part of the route, and must not be sent back to where they
+ * left it). SIZE_MAX when less than minLeftM of the route would be left after it: then a search to the destination
+ * is as short.
+ */
+size_t rejoinTarget(const Route& old, const RoutePoint& position, float progressM, float aheadM, float minLeftM);
+
+/**
+ * Whether going to the join point is a step towards the destination: false when the position is already nearer to
+ * the destination (in a straight line) than the join point by more than a third of the way to it, which is a way
+ * back, not a way on.
+ */
+bool rejoinLeadsOn(const RoutePoint& position, const RoutePoint& join, const RoutePoint& destination, float pieceM);
+
+/**
+ * Joins a found piece, which ends at old.points[target], with the old route from there on. Where the piece comes
+ * back along the old route before it ends (it met the route further ahead and ran back to the target), that spur
+ * is cut: the join is where the two first meet. False, and out empty, when the piece does not end at the target or
+ * memory ran out.
+ */
+bool spliceRoute(const Route& piece, const Route& old, size_t target, Route& out);
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/route/RouteTrack.cpp b/Apps/Maps/main/Source/route/RouteTrack.cpp
new file mode 100644
index 0000000..cd9cb58
--- /dev/null
+++ b/Apps/Maps/main/Source/route/RouteTrack.cpp
@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "RouteTrack.h"
+
+#include "RouteProfile.h"
+
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+
+namespace maps {
+
+void TrackRouteBuilder::beginLine(GpxKind kind, const char* lineName) {
+    (void)kind;
+    if (closed) {
+        return;
+    }
+    inLine = true;
+    // The name may come with the first point or at the end: the last one given counts
+    if (lineName != nullptr && lineName[0] != '\0') {
+        snprintf(name, sizeof(name), "%s", lineName);
+    }
+}
+
+void TrackRouteBuilder::point(const GpxPoint& gpxPoint) {
+    if (closed || gpxPoint.kind == GpxKind::Waypoint || !std::isfinite(gpxPoint.lat) || !std::isfinite(gpxPoint.lon)) {
+        return;
+    }
+    read++;
+    const RoutePoint here = routePointFrom(gpxPoint.lat, gpxPoint.lon);
+    if (points.size() > 0) {
+        const RoutePoint& last = points[points.size() - 1];
+        const float dx = static_cast<float>(here.x - last.x);
+        const float dy = static_cast<float>(here.y - last.y);
+        const float metres = std::sqrt(dx * dx + dy * dy) * static_cast<float>(routeMetresPerUnit(here.y));
+        if (metres < spacingM) {
+            return;
+        }
+    }
+    points.push(here);
+    if (points.size() > MAX_POINTS) {
+        // Thinned in place: every second point goes, and from now on points come twice as far apart
+        size_t kept = 0;
+        for (size_t i = 0; i < points.size(); i += 2) {
+            points[kept++] = points[i];
+        }
+        points.resize(kept);
+        spacingM *= 2.0f;
+    }
+}
+
+void TrackRouteBuilder::endLine() {
+    if (closed || !inLine) {
+        return;
+    }
+    inLine = false;
+    if (points.size() >= 2) {
+        closed = true;
+    } else {
+        // An empty line (or one point): the next line gets its chance
+        points.clear();
+        name[0] = '\0';
+    }
+}
+
+bool TrackRouteBuilder::finish(Route& out) {
+    out.clear();
+    if (points.size() < 2 || points.failed()) {
+        return false;
+    }
+    out.profile = RouteProfile::Walk;
+    out.track = true;
+    out.from = points[0];
+    out.to = points[points.size() - 1];
+    float distance = 0.0f;
+    for (size_t i = 0; i < points.size(); i++) {
+        if (i > 0) {
+            const RoutePoint& a = points[i - 1];
+            const RoutePoint& b = points[i];
+            const float dx = static_cast<float>(b.x - a.x);
+            const float dy = static_cast<float>(b.y - a.y);
+            distance += std::sqrt(dx * dx + dy * dy) * static_cast<float>(routeMetresPerUnit((a.y + b.y) / 2));
+        }
+        out.points.push(points[i]);
+        out.distances.push(distance);
+    }
+    out.lengthM = distance;
+    out.seconds = distance / (WALK_KMH / 3.6f);
+    // One step over the whole line, with its name: the bar and the saved file have something to show
+    const size_t length = strlen(name);
+    for (size_t i = 0; i < length; i++) {
+        out.names.push(name[i]);
+    }
+    out.steps.push({ 0, 0, static_cast<uint8_t>(length), 0, 0 });
+    if (out.points.failed() || out.distances.failed() || out.names.failed() || out.steps.failed()) {
+        out.clear();
+        return false;
+    }
+    return true;
+}
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/route/RouteTrack.h b/Apps/Maps/main/Source/route/RouteTrack.h
new file mode 100644
index 0000000..6f35533
--- /dev/null
+++ b/Apps/Maps/main/Source/route/RouteTrack.h
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "RouteSearch.h"
+
+#include "../gpx/GpxReader.h"
+
+namespace maps {
+
+/**
+ * Makes a route out of a GPX file's first track or route (0.6.0), so the follower can lead along it like along a
+ * route the search found: feed the file to a GpxReader with this as its listener, then finish().
+ *
+ * Only the first line with at least two points is taken (all segments of a track). Points closer than a few metres
+ * to the one before are left out, and a very long track is thinned while it is read, so memory stays bounded.
+ * The route has no turns (it is not known which roads the track follows): one step with the line's name, the
+ * walking time for its length, and `track` set.
+ */
+class TrackRouteBuilder : public GpxListener {
+public:
+    /** No route is given more points: a long track is thinned to fit (every second point goes, again and again). */
+    static constexpr size_t MAX_POINTS = 6000;
+
+    void beginLine(GpxKind kind, const char* name) override;
+    void point(const GpxPoint& point) override;
+    void endLine() override;
+
+    /** False when the file had no line of two points or memory ran out; out is then empty. */
+    bool finish(Route& out);
+    size_t pointsRead() const { return read; }
+
+private:
+    GrowArray<RoutePoint> points;
+    char name[48] = "";
+    /** A line with at least two points was read to its end: later lines are not taken. */
+    bool closed = false;
+    bool inLine = false;
+    /** Points closer than this to the last one kept are left out; grows when the track is thinned. */
+    float spacingM = 2.0f;
+    size_t read = 0;
+};
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/search/FoldTable.h b/Apps/Maps/main/Source/search/FoldTable.h
index f826ce2..00452b5 100644
--- a/Apps/Maps/main/Source/search/FoldTable.h
+++ b/Apps/Maps/main/Source/search/FoldTable.h
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Made by tools/make_fold_table.py from fold.py and Python's unicodedata 13.0.0; don't edit.
+// Made by host/search/make_fold_table.py from fold.py and Python's unicodedata 13.0.0; don't edit.
 #pragma once
 
 #include <cstdint>
diff --git a/Apps/Maps/main/Source/search/QueryParse.cpp b/Apps/Maps/main/Source/search/QueryParse.cpp
index ca5e294..5ebd4cf 100644
--- a/Apps/Maps/main/Source/search/QueryParse.cpp
+++ b/Apps/Maps/main/Source/search/QueryParse.cpp
@@ -185,6 +185,15 @@ int parseQuery(const char* query, QueryReading out[3]) {
         while (*cur && !std::isspace((unsigned char)*cur) && start < 31) {
             toks[tok_count][start++] = *cur++;
         }
+        if (*cur && !std::isspace((unsigned char)*cur)) {
+            // Over-long word: cut on a UTF-8 character boundary and skip the rest of the word,
+            // so the rest cannot turn into a token of its own (a house number, say)
+            if (((unsigned char)*cur & 0xC0) == 0x80) {
+                while (start > 0 && ((unsigned char)toks[tok_count][start - 1] & 0xC0) == 0x80) start--;
+                if (start > 0) start--;
+            }
+            while (*cur && !std::isspace((unsigned char)*cur)) cur++;
+        }
         toks[tok_count][start] = 0;
         tok_count++;
     }
diff --git a/Apps/Maps/main/Source/search/SearchCommon.cpp b/Apps/Maps/main/Source/search/SearchCommon.cpp
new file mode 100644
index 0000000..72c994c
--- /dev/null
+++ b/Apps/Maps/main/Source/search/SearchCommon.cpp
@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "SearchCommon.h"
+
+#include "QueryParse.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+
+namespace maps {
+
+namespace {
+
+constexpr uint32_t NONE = UINT32_MAX;
+constexpr double PI_D = 3.14159265358979323846;
+
+size_t characterCount(const char* s, size_t bytes) {
+    size_t n = 0;
+    for (size_t i = 0; i < bytes; i++) {
+        if ((static_cast<uint8_t>(s[i]) & 0xC0) != 0x80) {
+            n++;
+        }
+    }
+    return n;
+}
+
+} // namespace
+
+double metresPerUnitAtTileY(double tileY) {
+    const double n = PI_D * (1.0 - 2.0 * tileY / 16384.0);
+    const double lat = std::atan(std::sinh(n));
+    return 40075016.686 * std::cos(lat) / (16384.0 * 4096.0);
+}
+
+// ------------------------------------------------------------------------------------------------ HashIndex
+
+void HashIndex::clear() {
+    full = false;
+    values.clear();
+    hashes.clear();
+    used = 0;
+}
+
+void HashIndex::release() {
+    full = false;
+    values.release();
+    hashes.release();
+    used = 0;
+}
+
+void HashIndex::put(uint64_t hash, uint32_t value) {
+    const size_t mask = values.size() - 1;
+    size_t i = static_cast<size_t>(hash) & mask;
+    while (values[i] != NONE) {
+        i = (i + 1) & mask;
+    }
+    values[i] = value;
+    hashes[i] = hash;
+}
+
+void HashIndex::insert(uint64_t hash, uint32_t value) {
+    if (full) {
+        return;
+    }
+    if ((used + 1) * 2 > values.size()) {
+        // Both new arrays first: without memory for both the old table stays as it was (find() keeps working on it)
+        // and the index is full, which failed() reports
+        const size_t capacity = values.size() < 1024 ? 1024 : values.size() * 2;
+        GrowArray<uint32_t> grownValues;
+        GrowArray<uint64_t> grownHashes;
+        if (!grownValues.resize(capacity) || !grownHashes.resize(capacity)) {
+            full = true;
+            return;
+        }
+        for (size_t i = 0; i < capacity; i++) {
+            grownValues[i] = NONE;
+        }
+        grownValues.swap(values);
+        grownHashes.swap(hashes);
+        // The old table is in the grown* arrays now
+        for (size_t i = 0; i < grownValues.size(); i++) {
+            if (grownValues[i] != NONE) {
+                put(grownHashes[i], grownValues[i]);
+            }
+        }
+    }
+    put(hash, value);
+    used++;
+}
+
+// ------------------------------------------------------------------------------------------------ KeyMaker
+
+void KeyMaker::sortKeyOf(const char* name, Translit profile, char* out, size_t outSize) {
+    if (!hasNonLatin(name)) {
+        foldLatin(name, out, outSize);
+    } else {
+        transliterate(name, profile, out, outSize);
+    }
+}
+
+bool KeyMaker::has(const char* key) const {
+    for (size_t i = 0; i < offsets.size(); i++) {
+        if (strcmp(&pool[offsets[i]], key) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void KeyMaker::add(const char* key) {
+    offsets.push(static_cast<uint32_t>(pool.size()));
+    for (const char* c = key;; c++) {
+        pool.push(*c);
+        if (*c == '\0') {
+            break;
+        }
+    }
+}
+
+bool KeyMaker::make(const char* name, const char* latin, const char* en, bool useEn, Translit profile) {
+    pool.clear();
+    offsets.clear();
+    // The sort key first in the pool (offset 0), not one of the keys
+    sortKeyOf(name, profile, scratch[4], BUFFER);
+    for (const char* c = scratch[4];; c++) {
+        pool.push(*c);
+        if (*c == '\0') {
+            break;
+        }
+    }
+    // fold.search_keys
+    int n = 0;
+    if (!hasNonLatin(name)) {
+        foldLatin(name, scratch[n++], BUFFER);
+        if (latin != nullptr && !hasNonLatin(latin)) {
+            foldLatin(latin, scratch[n++], BUFFER);
+        }
+    } else {
+        transliterate(name, profile, scratch[n++], BUFFER);
+        foldOriginal(name, scratch[n++], BUFFER);
+        if (latin != nullptr) {
+            foldLatin(latin, scratch[n++], BUFFER);
+        }
+    }
+    if (useEn && en != nullptr && !hasNonLatin(en)) {
+        foldLatin(en, scratch[n++], BUFFER);
+    }
+    for (int i = 0; i < n; i++) {
+        if (scratch[i][0] != '\0' && !has(scratch[i])) {
+            add(scratch[i]);
+        }
+    }
+    // fold.suffix_keys of each base key: the text from each later word of at least 3 characters
+    const size_t baseCount = offsets.size();
+    for (size_t b = 0; b < baseCount; b++) {
+        // The pool may move while keys are added: work on a copy
+        strncpy(scratch[4], &pool[offsets[b]], BUFFER - 1);
+        scratch[4][BUFFER - 1] = '\0';
+        const char* word = scratch[4];
+        bool first = true;
+        while (true) {
+            const char* space = strchr(word, ' ');
+            const size_t length = space != nullptr ? static_cast<size_t>(space - word) : strlen(word);
+            if (!first && characterCount(word, length) >= 3 && !has(word)) {
+                add(word);
+            }
+            first = false;
+            if (space == nullptr) {
+                break;
+            }
+            word = space + 1;
+        }
+    }
+    return !pool.failed() && !offsets.failed();
+}
+
+// ------------------------------------------------------------------------------------------------ number helpers
+
+HouseNumberStyle houseNumberStyle(const char* text) {
+    HouseNumberStyle k = {};
+    k.parsed = parseHouseNumber(text, strlen(text), k.number);
+    if (k.parsed) {
+        k.plain = k.number.aux == 0 && k.number.suffix == 0 && k.number.flags == 0;
+        k.slash = (k.number.flags & HOUSE_SLASH) != 0 && k.number.aux != 0;
+        k.secondSmaller = k.slash && k.number.aux < k.number.number;
+    }
+    return k;
+}
+
+int32_t houseVoteNumber(const char* text, bool slashSecond) {
+    const HouseNumberStyle kind = houseNumberStyle(text);
+    if (kind.parsed) {
+        if (kind.slash && slashSecond) {
+            return static_cast<int32_t>(kind.number.aux);
+        }
+        return static_cast<int32_t>(kind.number.number);
+    }
+    int32_t value = 0;
+    int digits = 0;
+    while (text[digits] >= '0' && text[digits] <= '9' && digits < 9) {
+        value = value * 10 + (text[digits] - '0');
+        digits++;
+    }
+    return digits > 0 ? value : -1;
+}
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/search/SearchCommon.h b/Apps/Maps/main/Source/search/SearchCommon.h
new file mode 100644
index 0000000..7b3535d
--- /dev/null
+++ b/Apps/Maps/main/Source/search/SearchCommon.h
@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "../route/GrowArray.h"
+#include "AddressMatch.h"
+#include "QueryParse.h"
+#include "SearchExtract.h"
+#include "SearchIndex.h"
+#include "TextFold.h"
+
+#include <cstddef>
+#include <cstdint>
+
+namespace maps {
+
+/** Metres per z14 unit at a tile row (fractional, e.g. the middle of a region's rows). */
+double metresPerUnitAtTileY(double tileY);
+
+/** An open-addressing table from a 64-bit hash to a caller's index; the caller's callback decides equality. */
+class HashIndex {
+public:
+    static constexpr uint32_t NONE = UINT32_MAX;
+    void clear();
+    void release();
+    /** The value stored under the hash for which eq(value) is true, or NONE. */
+    template <typename Eq>
+    uint32_t find(uint64_t hash, Eq eq) const {
+        if (values.size() == 0) {
+            return NONE;
+        }
+        const size_t mask = values.size() - 1;
+        for (size_t i = static_cast<size_t>(hash) & mask; values[i] != NONE; i = (i + 1) & mask) {
+            if (hashes[i] == hash && eq(values[i])) {
+                return values[i];
+            }
+        }
+        return NONE;
+    }
+    /** Adds a value (the caller has checked it is not there). */
+    void insert(uint64_t hash, uint32_t value);
+    /** A value could not be added (no memory to grow): the index misses it. */
+    bool failed() const { return full || values.failed() || hashes.failed(); }
+
+private:
+    void put(uint64_t hash, uint32_t value);
+    GrowArray<uint32_t> values;
+    GrowArray<uint64_t> hashes;
+    size_t used = 0;
+    bool full = false;
+};
+
+/**
+ * The search keys of a name as the study makes them (fold.search_keys and suffix_keys): the folded name (transliterated
+ * and original-folded for Greek and Cyrillic), name:latin, name_en when useEn, then the text from each later word of at
+ * least 3 characters. Duplicates are left out; the order is fixed. Also the name's sort key. Shared by the in-memory
+ * builder and the streaming one, so both make the same keys.
+ */
+class KeyMaker {
+public:
+    /** Makes the keys of a name; false when out of memory. */
+    bool make(const char* name, const char* latin, const char* en, bool useEn, Translit profile);
+    /** The sort key (name groups are ordered by it). */
+    const char* sortKey() const { return &pool[0]; }
+    uint32_t count() const { return static_cast<uint32_t>(offsets.size()); }
+    const char* key(uint32_t index) const { return &pool[offsets[index]]; }
+    /** Only the sort key, without the other keys. */
+    static void sortKeyOf(const char* name, Translit profile, char* out, size_t outSize);
+    void release() {
+        pool.release();
+        offsets.release();
+    }
+
+private:
+    static constexpr size_t BUFFER = 2048;
+    bool has(const char* key) const;
+    void add(const char* key);
+    char scratch[5][BUFFER] = {};
+    GrowArray<char> pool;
+    GrowArray<uint32_t> offsets;
+};
+
+struct RegionConfig {
+    /** Transliteration of Greek and Cyrillic names (the study's PROFILE map: Ukrainian for kyiv, Serbian for belgrade, else Russian). */
+    Translit profile = Translit::Russian;
+    /** Metres per z14 unit; 0 takes it from the middle row of the region's tiles. */
+    double metresPerUnit = 0.0;
+    /**
+     * Named lines of class path, track, aerialway, ferry and rail take part in the house matching. The study's counts
+     * leave them out; with them 88.3 % of Bratislava's numbers get the street of OSM's addr:street instead of 87.2 %
+     * (host/search/gt_cpp.py, 12 Nov 2026), and the brief asks for named paths and pedestrian streets.
+     */
+    bool matchPathLines = true;
+    /** For "x/y" numbers of a conscription/street region the vote compares the street number (second part). */
+    bool voteSlashSecond = true;
+    /** The share of plain numbers from which a region is in village mode, and of x/y numbers with a smaller second part for slash_second. */
+    double villageShare = 0.30;
+    double slashSecondShare = 0.80;
+};
+
+struct RegionStats {
+    uint32_t tiles = 0;
+    // What was extracted, deduplicated across tiles (for comparison with the study's counts)
+    uint32_t places = 0;
+    uint32_t namedPois = 0;
+    uint32_t unnamedPois = 0;
+    uint32_t otherNamed = 0;
+    uint32_t junkPoisSkipped = 0;
+    uint32_t streetNames = 0;
+    uint32_t lines = 0;
+    uint32_t clusters = 0;
+    uint32_t refOnlyLines = 0;
+    uint32_t settlements = 0;
+    uint32_t houses = 0;
+    // House number grammar
+    uint32_t plainNumbers = 0;
+    double plainShare = 0;
+    bool villageMode = false;
+    uint32_t slashNumbers = 0;
+    uint32_t slashSecondSmaller = 0;
+    double slashShare = 0;
+    bool slashSecond = false;
+    uint32_t textNumbers = 0;
+    // The path of each house number: street within 50 m, street 50 to 100 m, village only, none
+    uint32_t pathStreet50 = 0;
+    uint32_t pathStreet100 = 0;
+    uint32_t pathVillage = 0;
+    uint32_t pathNone = 0;
+    /** Houses that also went under a settlement while having a street (counted in the street paths above). */
+    uint32_t alsoVillage = 0;
+    uint32_t pseudoStreets = 0;
+    uint32_t droppedAddresses = 0;
+    uint32_t addresses = 0;
+};
+
+/** The house number's grammar as the region statistics count it (both builders use it, so their files match). */
+struct HouseNumberStyle {
+    bool parsed;
+    bool plain;
+    bool slash;
+    bool secondSmaller;
+    HouseNumber number;
+};
+HouseNumberStyle houseNumberStyle(const char* text);
+/** The street number a house votes with: the second part of "x/y" when slashSecond, else the first; -1 for none. */
+int32_t houseVoteNumber(const char* text, bool slashSecond);
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/search/SearchEngine.cpp b/Apps/Maps/main/Source/search/SearchEngine.cpp
index 1ef560e..7fa3e59 100644
--- a/Apps/Maps/main/Source/search/SearchEngine.cpp
+++ b/Apps/Maps/main/Source/search/SearchEngine.cpp
@@ -180,6 +180,57 @@ ResultGroup describeLabel(const char* label, char* type, size_t typeSize) {
     return ResultGroup::Natural;
 }
 
+/**
+ * How important a kind of point is when several exact-name results share a name: 1 settlements, 2 transport hubs and big
+ * public places, 3 everything else (also streets and unknown labels), 4 street furniture and stops. Without it a bus
+ * stop named like the main station, or a map board named like a mall, came first because it stood nearer. The label is
+ * a class table label ("poi/class/subclass", "place/city", "park/park"); a subclass entry wins over a class entry.
+ */
+uint8_t importanceOfLabel(const char* label) {
+    static const char* const BIG[] = {
+        "station", "halt", "subway", "aerodrome", "bus_station", "ferry_terminal", "hospital", "university", "college", "stadium", "mall",
+        "town_hall", "castle", "museum", "theatre", "cinema", "library", "zoo", "park", "attraction",
+    };
+    static const char* const MINOR[] = {
+        "bus_stop", "tram_stop", "platform", "information", "board", "map", "guidepost", "route_marker", "terminal", "bench", "waste_basket",
+        "post_box", "toilets", "atm", "parking", "bicycle_parking", "playground", "playground_equipment",
+    };
+    if (strncmp(label, "place/", 6) == 0) {
+        const char* classText = label + 6;
+        const bool minor = strcmp(classText, "isolated_dwelling") == 0 || strcmp(classText, "locality") == 0;
+        return minor ? 3 : 1;
+    }
+    if (strncmp(label, "aerodrome/", 10) == 0 || strncmp(label, "park/", 5) == 0) {
+        return 2;
+    }
+    if (strncmp(label, "poi/", 4) != 0) {
+        return 3;
+    }
+    const char* classText = label + 4;
+    const char* slash = strchr(classText, '/');
+    const size_t classLength = slash != nullptr ? static_cast<size_t>(slash - classText) : strlen(classText);
+    const char* sub = slash != nullptr ? slash + 1 : "";
+    const size_t subLength = strlen(sub);
+    for (int pass = 0; pass < 2; pass++) {
+        const char* text = pass == 0 ? sub : classText;
+        const size_t length = pass == 0 ? subLength : classLength;
+        if (length == 0) {
+            continue;
+        }
+        for (const char* entry : MINOR) {
+            if (strlen(entry) == length && strncmp(entry, text, length) == 0) {
+                return 4;
+            }
+        }
+        for (const char* entry : BIG) {
+            if (strlen(entry) == length && strncmp(entry, text, length) == 0) {
+                return 2;
+            }
+        }
+    }
+    return 3;
+}
+
 /** Whether the folded text of a name equals one of the keys (also its transliteration in the region's profile). */
 bool isExactName(const char* name, const char* const* keys, int keyCount, Translit profile) {
     char latin[KEY_BYTES * 2];
@@ -669,6 +720,10 @@ bool SearchEngine::collectAddresses(const Query& query, SearchOrigin) {
             if ((number.flags & HOUSE_SLASH) != 0 && number.aux != 0 && slot.slashSecond) {
                 wanted = number.aux;
             }
+            // 0xFFFF is what the index stores for a house number written as text, so it never means a real number
+            if (wanted >= 0xFFFF) {
+                continue;
+            }
             int suffix = number.suffix != 0 ? number.suffix : -1;
             for (int k = 0; k < keyCount; k++) {
                 GrowArray<SearchAddressHit> hits;
@@ -784,6 +839,10 @@ void SearchEngine::collectNames(const char* const* keys, int keyCount, SearchOri
                     c.result.group = exact ? ResultGroup::ExactName : kind;
                     c.result.slot = static_cast<uint8_t>(slotIndex);
                     c.priority = static_cast<uint8_t>(p);
+                    if (exact) {
+                        // the ranking compares rank before distance: importance first inside the exact names
+                        c.rank = importanceOfLabel(label);
+                    }
                     setGeo(c.result, c.distanceSq);
                     ranked.push(c);
                 }
@@ -808,6 +867,9 @@ void SearchEngine::collectNames(const char* const* keys, int keyCount, SearchOri
                     c.result.group = exact ? ResultGroup::ExactName : ResultGroup::Street;
                     c.result.slot = static_cast<uint8_t>(slotIndex);
                     c.priority = static_cast<uint8_t>(p);
+                    if (exact) {
+                        c.rank = 3;
+                    }
                     setGeo(c.result, c.distanceSq);
                     streets.push(c);
                 }
diff --git a/Apps/Maps/main/Source/search/SearchExtract.cpp b/Apps/Maps/main/Source/search/SearchExtract.cpp
index c42c312..60735e9 100644
--- a/Apps/Maps/main/Source/search/SearchExtract.cpp
+++ b/Apps/Maps/main/Source/search/SearchExtract.cpp
@@ -166,7 +166,8 @@ bool TileExtractor::beginFeature(const FeatureInfo& info) {
         shape = Shape::House;
         return true;
     }
-    // The display name is name, else name:latin, else name_en (data.py nm_of, without name_int)
+    // The display name is name, else name:latin, else name_en; a street with none of them takes name_int (0.6.0:
+    // Athens has 893 of 9,542 street lines with only that one)
     const char* shown = nullptr;
     size_t shownLength = 0;
     if (info.name != nullptr && info.nameLength > 0) {
@@ -180,6 +181,10 @@ bool TileExtractor::beginFeature(const FeatureInfo& info) {
         shownLength = info.nameEnLength;
     }
     if (info.layer == Layer::TransportationName) {
+        if (shown == nullptr && info.nameInt != nullptr && info.nameIntLength > 0) {
+            shown = info.nameInt;
+            shownLength = info.nameIntLength;
+        }
         if (shown == nullptr) {
             out->refOnlyLines++;
             return false;
diff --git a/Apps/Maps/main/Source/search/SearchIndex.cpp b/Apps/Maps/main/Source/search/SearchIndex.cpp
index e3099e3..8934127 100644
--- a/Apps/Maps/main/Source/search/SearchIndex.cpp
+++ b/Apps/Maps/main/Source/search/SearchIndex.cpp
@@ -167,151 +167,11 @@ uint32_t encodeTextAddress(uint8_t* out, uint32_t pointBytes, uint32_t textOffse
                          HOUSE_TEXT, relX, relY);
 }
 
-// ------------------------------------------------------------------------------------------------ writer
+// The writer (SearchIndexWriter::build) is the PC's reference and lives in host/oracle/SearchIndexWriter.cpp; the
+// device builds its index with SearchStreamBuilder. What both share stays here.
 
 namespace {
 
-enum Category : uint8_t { CAT_CATEGORY = 0, CAT_PLACE = 1, CAT_STREET = 2, CAT_OTHER = 3, CAT_POI = 4 };
-
-struct NameGroup {
-    const char* name;
-    uint32_t nameLength;
-    const char* sortKey;
-    uint32_t sortLength;
-    uint8_t kind;
-    uint8_t category;
-    uint32_t pair;
-    /** Order of creation, the tie-breaker of the sort (sidx.py sorts stably). */
-    uint32_t creation;
-    /** Point group: its first point (index into the input). Street: the street. Category: unused. */
-    uint32_t source;
-    uint32_t keysSource;
-    uint32_t first;
-    uint32_t count;
-    uint32_t offset;
-    /** Category: the run of pairs. */
-    uint32_t pairFirst;
-    uint32_t pairCount;
-};
-
-struct CategoryRun {
-    uint32_t rawOffset;
-    uint32_t rawLength;
-    uint32_t firstPair;
-    uint32_t lastPair;
-    uint32_t count;
-    bool contiguous;
-};
-
-struct PointRecord {
-    uint32_t pair;
-    uint32_t unnamed;
-    uint32_t ng;
-    int32_t tileY;
-    int32_t tileX;
-    int32_t x;
-    int32_t y;
-};
-
-struct KeyEntry {
-    uint32_t offset;
-    uint32_t length;
-    uint32_t ng;
-    uint8_t priority;
-};
-
-struct AddressTemp {
-    uint16_t number;
-    uint16_t aux;
-    uint8_t suffix;
-    uint8_t flags;
-    int32_t x, y;
-    uint32_t index;
-};
-
-struct StreetTemp {
-    const SearchClusterInput* cluster;
-    uint32_t firstAddress;
-    uint32_t count;
-};
-
-struct Failure {
-    char* text;
-    size_t size;
-    bool fail(const char* what, uint32_t a = 0, uint32_t b = 0) {
-        snprintf(text, size, what, a, b);
-        return false;
-    }
-};
-
-/** A very small hash set of overflow strings: offsets into the overflow bytes. */
-class OverflowTable {
-public:
-    /** Returns the offset of the text, adding it when new. UINT32_MAX when out of memory. */
-    uint32_t find(const char* text, size_t length) {
-        if ((used + 1) * 2 > slots.size()) {
-            if (!grow()) {
-                return UINT32_MAX;
-            }
-        }
-        uint32_t hash = hashOf(text, length);
-        size_t mask = slots.size() - 1;
-        for (size_t i = hash & mask;; i = (i + 1) & mask) {
-            uint32_t slot = slots[i];
-            if (slot == 0) {
-                uint32_t offset = static_cast<uint32_t>(bytes.size());
-                size_t at = bytes.size();
-                if (!bytes.resize(at + length + 1)) {
-                    return UINT32_MAX;
-                }
-                memcpy(bytes.begin() + at, text, length);
-                slots[i] = offset + 1;
-                used++;
-                count++;
-                return offset;
-            }
-            const char* stored = bytes.begin() + (slot - 1);
-            if (strlen(stored) == length && memcmp(stored, text, length) == 0) {
-                return slot - 1;
-            }
-        }
-    }
-    GrowArray<char> bytes;
-    uint32_t count = 0;
-
-private:
-    static uint32_t hashOf(const char* text, size_t length) {
-        uint32_t hash = 2166136261u;
-        for (size_t i = 0; i < length; i++) {
-            hash = (hash ^ static_cast<uint8_t>(text[i])) * 16777619u;
-        }
-        return hash;
-    }
-    bool grow() {
-        GrowArray<uint32_t> next;
-        size_t size = slots.size() < 64 ? 64 : slots.size() * 2;
-        if (!next.resize(size)) {
-            return false;
-        }
-        size_t mask = size - 1;
-        for (uint32_t slot : slots) {
-            if (slot == 0) {
-                continue;
-            }
-            const char* stored = bytes.begin() + (slot - 1);
-            size_t i = hashOf(stored, strlen(stored)) & mask;
-            while (next[i] != 0) {
-                i = (i + 1) & mask;
-            }
-            next[i] = slot;
-        }
-        slots.swap(next);
-        return true;
-    }
-    GrowArray<uint32_t> slots;
-    size_t used = 0;
-};
-
 /** Folds a category name (an OSM class made of ASCII): lowercase, anything but letters and digits is a space, runs of spaces are one. */
 uint32_t foldCategory(const char* name, char* out, size_t capacity) {
     uint32_t length = 0;
@@ -392,636 +252,6 @@ bool indexHouseNumber(const char* text, bool slashSecond, uint16_t& number, uint
     return parseNumber(text, slashSecond, number, aux, suffix, flags);
 }
 
-bool SearchIndexWriter::build(const SearchInput& in, ByteSink& sink, SearchBuildStats* stats) {
-    errorText[0] = 0;
-    Failure failure = { errorText, sizeof(errorText) };
-    const SearchPointInput* points = in.points;
-    const uint32_t pointCount = in.pointCount;
-    const SearchStreetInput* streets = in.streets;
-    const uint32_t streetCount = in.streetCount;
-
-    // ---- origin and point size
-    bool anyPoint = false;
-    int32_t minX = 0, minY = 0, maxX = 0, maxY = 0;
-    auto include = [&](int32_t x, int32_t y) {
-        if (!anyPoint) {
-            minX = maxX = x;
-            minY = maxY = y;
-            anyPoint = true;
-            return;
-        }
-        minX = std::min(minX, x);
-        maxX = std::max(maxX, x);
-        minY = std::min(minY, y);
-        maxY = std::max(maxY, y);
-    };
-    for (uint32_t i = 0; i < pointCount; i++) {
-        include(points[i].x, points[i].y);
-    }
-    for (uint32_t s = 0; s < streetCount; s++) {
-        for (uint32_t c = 0; c < streets[s].clusterCount; c++) {
-            const SearchClusterInput& cl = streets[s].clusters[c];
-            include(cl.repX, cl.repY);
-            include(cl.minX, cl.minY);
-            include(cl.maxX, cl.maxY);
-            for (uint32_t a = 0; a < cl.addressCount; a++) {
-                include(cl.addresses[a].x, cl.addresses[a].y);
-            }
-        }
-    }
-    const int32_t originX = minX, originY = minY;
-    const int64_t span = std::max<int64_t>(static_cast<int64_t>(maxX) - minX, static_cast<int64_t>(maxY) - minY);
-    const bool wide = span >= 65536;
-    const uint32_t pts = wide ? 8 : 4;
-
-    // ---- class pairs: unique labels (sorted by text), folded into "<class>/(all)" when there are more than 255
-    GrowArray<uint32_t> order;
-    order.resize(pointCount);
-    for (uint32_t i = 0; i < pointCount; i++) {
-        if (points[i].label == nullptr) {
-            return failure.fail("point %u has no label", i);
-        }
-        order[i] = i;
-    }
-    std::sort(order.begin(), order.end(), [&](uint32_t a, uint32_t b) {
-        int c = strcmp(points[a].label, points[b].label);
-        return c != 0 ? c < 0 : a < b;
-    });
-    GrowArray<uint32_t> uniqueOf, uniqueFirst, uniqueCount;
-    uniqueOf.resize(pointCount);
-    for (uint32_t k = 0; k < pointCount; k++) {
-        uint32_t i = order[k];
-        if (k == 0 || strcmp(points[order[k - 1]].label, points[i].label) != 0) {
-            uniqueFirst.push(i);
-            uniqueCount.push(0);
-        }
-        uniqueOf[i] = static_cast<uint32_t>(uniqueFirst.size() - 1);
-        uniqueCount[uniqueCount.size() - 1]++;
-        if (i < uniqueFirst[uniqueFirst.size() - 1]) {
-            uniqueFirst[uniqueFirst.size() - 1] = i;
-        }
-    }
-    const uint32_t uniqueTotal = static_cast<uint32_t>(uniqueFirst.size());
-    GrowArray<uint8_t> keep;
-    keep.resize(uniqueTotal);
-    uint32_t collapsed = 0;
-    if (uniqueTotal > 255) {
-        GrowArray<uint32_t> byCount;
-        byCount.resize(uniqueTotal);
-        for (uint32_t u = 0; u < uniqueTotal; u++) {
-            byCount[u] = u;
-        }
-        std::sort(byCount.begin(), byCount.end(), [&](uint32_t a, uint32_t b) {
-            return uniqueCount[a] != uniqueCount[b] ? uniqueCount[a] > uniqueCount[b] : uniqueFirst[a] < uniqueFirst[b];
-        });
-        for (uint32_t k = 0; k < 110; k++) {
-            keep[byCount[k]] = 1;
-        }
-        collapsed = uniqueTotal - 110;
-    } else {
-        for (uint32_t u = 0; u < uniqueTotal; u++) {
-            keep[u] = 1;
-        }
-    }
-    GrowArray<char> labelBytes;
-    GrowArray<uint32_t> labelOffset;
-    labelOffset.resize(uniqueTotal);
-    for (uint32_t u = 0; u < uniqueTotal; u++) {
-        const char* label = points[uniqueFirst[u]].label;
-        size_t length = strlen(label);
-        size_t keepLength = length;
-        const char* suffix = "";
-        if (!keep[u]) {
-            const char* slash = strchr(label, '/');
-            const char* second = slash != nullptr ? strchr(slash + 1, '/') : nullptr;
-            keepLength = second != nullptr ? static_cast<size_t>(second - label) : length;
-            suffix = "/*";
-        }
-        size_t at = labelBytes.size();
-        labelOffset[u] = static_cast<uint32_t>(at);
-        labelBytes.resize(at + keepLength + strlen(suffix) + 1);
-        memcpy(labelBytes.begin() + at, label, keepLength);
-        memcpy(labelBytes.begin() + at + keepLength, suffix, strlen(suffix));
-    }
-    if (labelBytes.failed()) {
-        return failure.fail("out of memory");
-    }
-    GrowArray<uint32_t> labelOrder;
-    labelOrder.resize(uniqueTotal);
-    for (uint32_t u = 0; u < uniqueTotal; u++) {
-        labelOrder[u] = u;
-    }
-    const char* labelBase = labelBytes.begin();
-    std::sort(labelOrder.begin(), labelOrder.end(), [&](uint32_t a, uint32_t b) {
-        int c = strcmp(labelBase + labelOffset[a], labelBase + labelOffset[b]);
-        return c != 0 ? c < 0 : a < b;
-    });
-    GrowArray<uint32_t> pairOfUnique, pairLabel;   // pairLabel: a unique label with that pair's text
-    pairOfUnique.resize(uniqueTotal);
-    for (uint32_t k = 0; k < uniqueTotal; k++) {
-        uint32_t u = labelOrder[k];
-        if (k == 0 || strcmp(labelBase + labelOffset[labelOrder[k - 1]], labelBase + labelOffset[u]) != 0) {
-            pairLabel.push(u);
-        }
-        pairOfUnique[u] = static_cast<uint32_t>(pairLabel.size() - 1);
-    }
-    const uint32_t pairTotal = static_cast<uint32_t>(pairLabel.size());
-    if (pairTotal > 255) {
-        return failure.fail("%u class pairs do not fit a byte", pairTotal);
-    }
-    auto pairText = [&](uint32_t pair) { return labelBase + labelOffset[pairLabel[pair]]; };
-    for (uint32_t pair = 0; pair < pairTotal; pair++) {
-        if (strlen(pairText(pair)) > 255) {
-            return failure.fail("class label %u is longer than 255 bytes", pair);
-        }
-    }
-    GrowArray<uint8_t> pairOf;
-    pairOf.resize(pointCount);
-    for (uint32_t i = 0; i < pointCount; i++) {
-        pairOf[i] = static_cast<uint8_t>(pairOfUnique[uniqueOf[i]]);
-    }
-
-    // ---- category runs: class and subclass names of "poi/<class>/<subclass>" pairs
-    GrowArray<char> catChars;
-    GrowArray<CategoryRun> classRuns, subRuns;
-    uint32_t notContiguous = 0;
-    auto addRun = [&](GrowArray<CategoryRun>& runs, const char* raw, size_t rawLength, uint32_t pair) {
-        for (CategoryRun& run : runs) {
-            if (run.rawLength == rawLength && memcmp(catChars.begin() + run.rawOffset, raw, rawLength) == 0) {
-                if (pair != run.lastPair + 1) {
-                    run.contiguous = false;
-                }
-                run.lastPair = pair;
-                run.count++;
-                return;
-            }
-        }
-        CategoryRun run = {};
-        run.rawOffset = static_cast<uint32_t>(catChars.size());
-        run.rawLength = static_cast<uint32_t>(rawLength);
-        run.firstPair = run.lastPair = pair;
-        run.count = 1;
-        run.contiguous = true;
-        size_t at = catChars.size();
-        catChars.resize(at + rawLength + 1);
-        memcpy(catChars.begin() + at, raw, rawLength);
-        runs.push(run);
-    };
-    for (uint32_t pair = 0; pair < pairTotal; pair++) {
-        const char* label = pairText(pair);
-        if (strncmp(label, "poi/", 4) != 0) {
-            continue;
-        }
-        const char* classStart = label + 4;
-        const char* classEnd = strchr(classStart, '/');
-        size_t classLength = classEnd != nullptr ? static_cast<size_t>(classEnd - classStart) : strlen(classStart);
-        addRun(classRuns, classStart, classLength, pair);
-        if (classEnd != nullptr) {
-            const char* subStart = classEnd + 1;
-            const char* subEnd = strchr(subStart, '/');
-            size_t subLength = subEnd != nullptr ? static_cast<size_t>(subEnd - subStart) : strlen(subStart);
-            if (!(subLength == classLength && memcmp(subStart, classStart, subLength) == 0)) {
-                addRun(subRuns, subStart, subLength, pair);
-            }
-        }
-    }
-    // display names ("pet_shop" -> "pet shop") and their sort keys, kept after the raw names
-    struct CategoryText {
-        uint32_t nameOffset, nameLength, sortOffset, sortLength;
-        CategoryRun run;
-    };
-    GrowArray<CategoryText> categories;
-    for (int which = 0; which < 2; which++) {
-        for (const CategoryRun& run : which == 0 ? classRuns : subRuns) {
-            if (!run.contiguous) {
-                notContiguous++;
-                continue;
-            }
-            CategoryText text = {};
-            text.run = run;
-            char name[128];
-            uint32_t length = std::min<uint32_t>(run.rawLength, sizeof(name) - 1);
-            memcpy(name, catChars.begin() + run.rawOffset, length);
-            for (uint32_t i = 0; i < length; i++) {
-                if (name[i] == '_') {
-                    name[i] = ' ';
-                }
-            }
-            name[length] = 0;
-            char folded[128];
-            uint32_t foldedLength = foldCategory(name, folded, sizeof(folded));
-            for (uint32_t o = 0; o < in.categoryOverrides; o++) {
-                if (strcmp(in.categoryNames[o], name) == 0) {
-                    foldedLength = std::min<uint32_t>(static_cast<uint32_t>(strlen(in.categoryKeys[o])), sizeof(folded) - 1);
-                    memcpy(folded, in.categoryKeys[o], foldedLength);
-                    folded[foldedLength] = 0;
-                    break;
-                }
-            }
-            text.nameOffset = static_cast<uint32_t>(catChars.size());
-            text.nameLength = length;
-            catChars.resize(catChars.size() + length + 1);
-            memcpy(catChars.begin() + text.nameOffset, name, length);
-            text.sortOffset = static_cast<uint32_t>(catChars.size());
-            text.sortLength = foldedLength;
-            catChars.resize(catChars.size() + foldedLength + 1);
-            memcpy(catChars.begin() + text.sortOffset, folded, foldedLength);
-            categories.push(text);
-        }
-    }
-    if (catChars.failed() || categories.failed()) {
-        return failure.fail("out of memory");
-    }
-
-    // ---- name groups
-    GrowArray<NameGroup> created;
-    GrowArray<uint32_t> groupOfPoint;   // created index of a named point's group
-    groupOfPoint.resize(pointCount);
-    {
-        GrowArray<uint32_t> named;
-        for (uint32_t i = 0; i < pointCount; i++) {
-            if (points[i].name != nullptr) {
-                named.push(i);
-            }
-        }
-        std::sort(named.begin(), named.end(), [&](uint32_t a, uint32_t b) {
-            int c = strcmp(points[a].name, points[b].name);
-            if (c != 0) {
-                return c < 0;
-            }
-            return pairOf[a] != pairOf[b] ? pairOf[a] < pairOf[b] : a < b;
-        });
-        for (size_t k = 0; k < named.size(); k++) {
-            uint32_t i = named[k];
-            bool head = k == 0 || strcmp(points[named[k - 1]].name, points[i].name) != 0 || pairOf[named[k - 1]] != pairOf[i];
-            if (head) {
-                NameGroup group = {};
-                group.name = points[i].name;
-                group.nameLength = truncateName(group.name, strlen(group.name));
-                group.sortKey = points[i].sortKey != nullptr ? points[i].sortKey : "";
-                group.sortLength = static_cast<uint32_t>(strlen(group.sortKey));
-                group.kind = static_cast<uint8_t>(SearchKind::Point);
-                const char* label = points[i].label;
-                group.category = strncmp(label, "poi/", 4) == 0 ? CAT_POI : (strncmp(label, "place/", 6) == 0 ? CAT_PLACE : CAT_OTHER);
-                group.pair = pairOf[i];
-                group.creation = i;
-                group.source = i;
-                created.push(group);
-            }
-            groupOfPoint[i] = static_cast<uint32_t>(created.size() - 1);
-        }
-    }
-    for (uint32_t s = 0; s < streetCount; s++) {
-        NameGroup group = {};
-        group.name = streets[s].name;
-        group.nameLength = truncateName(group.name, strlen(group.name));
-        group.sortKey = streets[s].sortKey != nullptr ? streets[s].sortKey : "";
-        group.sortLength = static_cast<uint32_t>(strlen(group.sortKey));
-        group.kind = static_cast<uint8_t>(SearchKind::Street);
-        group.category = CAT_STREET;
-        group.creation = pointCount + s;
-        group.source = s;
-        created.push(group);
-    }
-    for (uint32_t c = 0; c < categories.size(); c++) {
-        NameGroup group = {};
-        group.name = catChars.begin() + categories[c].nameOffset;
-        group.nameLength = truncateName(group.name, categories[c].nameLength);
-        group.sortKey = catChars.begin() + categories[c].sortOffset;
-        group.sortLength = categories[c].sortLength;
-        group.kind = static_cast<uint8_t>(SearchKind::Category);
-        group.category = CAT_CATEGORY;
-        group.creation = pointCount + streetCount + c;
-        group.source = c;
-        group.pairFirst = categories[c].run.firstPair;
-        group.pairCount = categories[c].run.count;
-        created.push(group);
-    }
-    if (created.failed()) {
-        return failure.fail("out of memory");
-    }
-    const uint32_t groupTotal = static_cast<uint32_t>(created.size());
-    GrowArray<uint32_t> groupOrder;
-    groupOrder.resize(groupTotal);
-    for (uint32_t g = 0; g < groupTotal; g++) {
-        groupOrder[g] = g;
-    }
-    std::sort(groupOrder.begin(), groupOrder.end(), [&](uint32_t a, uint32_t b) {
-        const NameGroup& x = created[a];
-        const NameGroup& y = created[b];
-        if (x.kind != y.kind) {
-            return x.kind < y.kind;
-        }
-        int c = compareBytes(reinterpret_cast<const uint8_t*>(x.sortKey), x.sortLength, reinterpret_cast<const uint8_t*>(y.sortKey),
-                             y.sortLength);
-        if (c != 0) {
-            return c < 0;
-        }
-        if (x.pair != y.pair) {
-            return x.pair < y.pair;
-        }
-        return x.creation < y.creation;
-    });
-    GrowArray<NameGroup> groups;
-    GrowArray<uint32_t> newIndex;
-    groups.resize(groupTotal);
-    newIndex.resize(groupTotal);
-    uint32_t groupBytes = 0;
-    for (uint32_t k = 0; k < groupTotal; k++) {
-        groups[k] = created[groupOrder[k]];
-        newIndex[groupOrder[k]] = k;
-        groups[k].offset = groupBytes;
-        groupBytes += 1 + groups[k].nameLength + 1 + 4 + 2;
-    }
-    if (groupBytes >= SIDX_MAX_OFFSET24) {
-        return failure.fail("the name groups take %u bytes, more than 16 MB", groupBytes);
-    }
-
-    // ---- point records, sorted by (pair, named first, name group, tile)
-    GrowArray<PointRecord> records;
-    records.resize(pointCount);
-    for (uint32_t i = 0; i < pointCount; i++) {
-        PointRecord& r = records[i];
-        r.pair = pairOf[i];
-        r.unnamed = points[i].name == nullptr ? 1 : 0;
-        r.ng = r.unnamed ? 0 : newIndex[groupOfPoint[i]];
-        r.tileY = points[i].y >> 12;
-        r.tileX = points[i].x >> 12;
-        r.x = points[i].x;
-        r.y = points[i].y;
-    }
-    std::sort(records.begin(), records.end(), [](const PointRecord& a, const PointRecord& b) {
-        if (a.pair != b.pair) return a.pair < b.pair;
-        if (a.unnamed != b.unnamed) return a.unnamed < b.unnamed;
-        if (a.ng != b.ng) return a.ng < b.ng;
-        if (a.tileY != b.tileY) return a.tileY < b.tileY;
-        if (a.tileX != b.tileX) return a.tileX < b.tileX;
-        if (a.x != b.x) return a.x < b.x;
-        return a.y < b.y;
-    });
-    GrowArray<uint32_t> firstOf, countOf, pairStart, pairCount;
-    firstOf.resize(groupTotal);
-    countOf.resize(groupTotal);
-    pairStart.resize(pairTotal);
-    pairCount.resize(pairTotal);
-    for (uint32_t i = 0; i < pointCount; i++) {
-        const PointRecord& r = records[i];
-        if (!r.unnamed) {
-            if (countOf[r.ng] == 0) {
-                firstOf[r.ng] = i;
-            }
-            countOf[r.ng]++;
-        }
-        if (pairCount[r.pair] == 0) {
-            pairStart[r.pair] = i;
-        }
-        pairCount[r.pair]++;
-    }
-
-    // ---- street records and addresses, in name group order
-    GrowArray<StreetTemp> streetRecords;
-    GrowArray<uint8_t> addressBlob;
-    OverflowTable overflow;
-    uint32_t addressTotal = 0;
-    for (uint32_t k = 0; k < groupTotal; k++) {
-        NameGroup& g = groups[k];
-        if (g.kind != static_cast<uint8_t>(SearchKind::Street)) {
-            continue;
-        }
-        const SearchStreetInput& street = streets[g.source];
-        if (street.clusterCount > 0xFFFF) {
-            return failure.fail("a street has %u clusters, the limit is 65535", street.clusterCount);
-        }
-        g.first = static_cast<uint32_t>(streetRecords.size());
-        g.count = street.clusterCount;
-        for (uint32_t c = 0; c < street.clusterCount; c++) {
-            const SearchClusterInput& cluster = street.clusters[c];
-            if (cluster.addressCount > 0xFFFF) {
-                return failure.fail("a street cluster has %u addresses, the limit is 65535", cluster.addressCount);
-            }
-            GrowArray<AddressTemp> temp;
-            for (uint32_t a = 0; a < cluster.addressCount; a++) {
-                const SearchAddressInput& in2 = cluster.addresses[a];
-                AddressTemp t = {};
-                t.x = in2.x - originX;
-                t.y = in2.y - originY;
-                t.index = a;
-                if (!parseNumber(in2.number, in.slashSecond, t.number, t.aux, t.suffix, t.flags)) {
-                    uint32_t at = overflow.find(in2.number, strlen(in2.number));
-                    if (at == UINT32_MAX || at >= SIDX_MAX_OFFSET24) {
-                        return failure.fail("the overflow strings pass 16 MB");
-                    }
-                    t.number = 0xFFFF;
-                    t.aux = static_cast<uint16_t>(at & 0xFFFF);
-                    t.suffix = static_cast<uint8_t>(at >> 16);
-                    t.flags = HOUSE_TEXT;
-                }
-                t.flags = static_cast<uint8_t>(t.flags | in2.flags);
-                temp.push(t);
-            }
-            std::sort(temp.begin(), temp.end(), [](const AddressTemp& a, const AddressTemp& b) {
-                if (a.number != b.number) return a.number < b.number;
-                if (a.aux != b.aux) return a.aux < b.aux;
-                if (a.suffix != b.suffix) return a.suffix < b.suffix;
-                return a.index < b.index;
-            });
-            StreetTemp rec = { &cluster, addressTotal, cluster.addressCount };
-            streetRecords.push(rec);
-            for (const AddressTemp& t : temp) {
-                uint8_t bytes[16];
-                uint32_t size = encodeAddress(bytes, pts, t.number, t.aux, t.suffix, t.flags, t.x, t.y);
-                appendBytes(addressBlob, bytes, size);
-            }
-            addressTotal += cluster.addressCount;
-        }
-    }
-
-    // ---- name group counts, then the name group area and the point and street records
-    for (uint32_t k = 0; k < groupTotal; k++) {
-        NameGroup& g = groups[k];
-        if (g.kind == static_cast<uint8_t>(SearchKind::Point)) {
-            g.first = firstOf[k];
-            g.count = countOf[k];
-        } else if (g.kind == static_cast<uint8_t>(SearchKind::Category)) {
-            g.first = pairStart[g.pairFirst];
-            g.count = 0;
-            for (uint32_t p = 0; p < g.pairCount; p++) {
-                g.count += pairCount[g.pairFirst + p];
-            }
-        }
-        if (g.count > 0xFFFF) {
-            return failure.fail("name group %u has more than 65535 records", k);
-        }
-    }
-    GrowArray<uint8_t> groupBlob;
-    for (uint32_t k = 0; k < groupTotal; k++) {
-        uint8_t bytes[SIDX_MAX_NAME + 8];
-        uint32_t size = encodeNameGroup(bytes, groups[k].name, groups[k].nameLength, static_cast<SearchKind>(groups[k].kind), groups[k].first,
-                                        static_cast<uint16_t>(groups[k].count));
-        appendBytes(groupBlob, bytes, size);
-    }
-    GrowArray<uint8_t> pointBlob;
-    for (uint32_t i = 0; i < pointCount; i++) {
-        const PointRecord& r = records[i];
-        uint8_t bytes[16];
-        uint32_t size = encodePoint(bytes, pts, r.x - originX, r.y - originY, static_cast<uint8_t>(r.pair),
-                                    r.unnamed ? SIDX_UNNAMED : groups[r.ng].offset);
-        appendBytes(pointBlob, bytes, size);
-    }
-    GrowArray<uint8_t> streetBlob;
-    for (const StreetTemp& s : streetRecords) {
-        const SearchClusterInput& c = *s.cluster;
-        int32_t rep[2] = { c.repX - originX, c.repY - originY };
-        int32_t lo[2] = { c.minX - originX, c.minY - originY };
-        int32_t hi[2] = { c.maxX - originX, c.maxY - originY };
-        uint8_t bytes[32];
-        uint32_t size = encodeStreet(bytes, pts, rep, lo, hi, s.firstAddress, static_cast<uint16_t>(s.count));
-        appendBytes(streetBlob, bytes, size);
-    }
-
-    // ---- keys, key pages and fence
-    GrowArray<char> keyBytes;
-    GrowArray<KeyEntry> entries;
-    for (uint32_t k = 0; k < groupTotal; k++) {
-        const NameGroup& g = groups[k];
-        const char* const* keys = nullptr;
-        uint32_t keyCount = 0;
-        const char* categoryKey[1];
-        if (g.kind == static_cast<uint8_t>(SearchKind::Point)) {
-            keys = points[g.source].keys;
-            keyCount = points[g.source].keyCount;
-        } else if (g.kind == static_cast<uint8_t>(SearchKind::Street)) {
-            keys = streets[g.source].keys;
-            keyCount = streets[g.source].keyCount;
-        } else {
-            categoryKey[0] = g.sortKey;
-            keys = categoryKey;
-            keyCount = 1;
-        }
-        for (uint32_t i = 0; i < keyCount; i++) {
-            size_t length = strlen(keys[i]);
-            if (length == 0) {
-                continue;
-            }
-            KeyEntry e = {};
-            e.length = truncateKey(keys[i], length);
-            e.offset = static_cast<uint32_t>(keyBytes.size());
-            e.ng = g.offset;
-            e.priority = g.category;
-            size_t at = keyBytes.size();
-            keyBytes.resize(at + e.length);
-            memcpy(keyBytes.begin() + at, keys[i], e.length);
-            entries.push(e);
-        }
-    }
-    if (keyBytes.failed() || entries.failed()) {
-        return failure.fail("out of memory");
-    }
-    const uint8_t* keyBase = reinterpret_cast<const uint8_t*>(keyBytes.begin());
-    std::sort(entries.begin(), entries.end(), [&](const KeyEntry& a, const KeyEntry& b) {
-        int c = compareBytes(keyBase + a.offset, a.length, keyBase + b.offset, b.length);
-        if (c != 0) return c < 0;
-        if (a.priority != b.priority) return a.priority < b.priority;
-        return a.ng < b.ng;
-    });
-    GrowArray<uint8_t> keyBlob, fenceBlob;
-    uint32_t pageCount = 0, fenceCount = 0;
-    {
-        uint8_t page[SIDX_PAGE_SIZE];
-        uint32_t used = 0;
-        memset(page, 0, sizeof(page));
-        for (const KeyEntry& e : entries) {
-            if (!encodeKeyPage(page, used, keyBase + e.offset, e.length, e.ng)) {
-                appendBytes(keyBlob, page, SIDX_PAGE_SIZE);
-                pageCount++;
-                memset(page, 0, sizeof(page));
-                used = 0;
-                if (!encodeKeyPage(page, used, keyBase + e.offset, e.length, e.ng)) {
-                    return failure.fail("a key does not fit a page");
-                }
-            }
-            if (used == 1 + e.length + 3) {
-                uint8_t length = static_cast<uint8_t>(e.length);
-                appendBytes(fenceBlob, &length, 1);
-                appendBytes(fenceBlob, keyBase + e.offset, e.length);
-                fenceCount++;
-            }
-        }
-        if (used > 0) {
-            appendBytes(keyBlob, page, SIDX_PAGE_SIZE);
-            pageCount++;
-        }
-    }
-    GrowArray<uint8_t> classBlob;
-    for (uint32_t pair = 0; pair < pairTotal; pair++) {
-        const char* label = pairText(pair);
-        uint8_t length = static_cast<uint8_t>(strlen(label));
-        uint8_t tail[8];
-        put32(tail, pairStart[pair]);
-        put32(tail + 4, pairCount[pair]);
-        appendBytes(classBlob, &length, 1);
-        appendBytes(classBlob, label, length);
-        appendBytes(classBlob, tail, 8);
-    }
-    if (pointBlob.failed() || streetBlob.failed() || addressBlob.failed() || groupBlob.failed() || keyBlob.failed() || fenceBlob.failed() ||
-        classBlob.failed() || overflow.bytes.failed() || groups.failed()) {
-        return failure.fail("out of memory");
-    }
-
-    // ---- assemble
-    const GrowArray<uint8_t>* parts[SIDX_SECTION_COUNT] = { &classBlob, &fenceBlob, &keyBlob, &groupBlob, &pointBlob, &streetBlob, &addressBlob, nullptr };
-    SearchHeader header = {};
-    header.pointBytes = static_cast<uint16_t>(pts);
-    header.originX = originX;
-    header.originY = originY;
-    header.classCount = pairTotal;
-    header.fenceCount = fenceCount;
-    header.pageCount = pageCount;
-    header.pointCount = pointCount;
-    header.streetCount = static_cast<uint32_t>(streetRecords.size());
-    header.addressCount = addressTotal;
-    uint64_t offset = SIDX_HEADER_SIZE;
-    for (uint32_t i = 0; i < SIDX_SECTION_COUNT; i++) {
-        uint64_t size = parts[i] != nullptr ? parts[i]->size() : overflow.bytes.size();
-        header.sectionOffset[i] = static_cast<uint32_t>(offset);
-        header.sectionSize[i] = static_cast<uint32_t>(size);
-        offset += size;
-    }
-    if (offset > 0xFFFFFFFFull) {
-        return failure.fail("the index is larger than 4 GB");
-    }
-    uint8_t headerBytes[SIDX_HEADER_SIZE];
-    encodeHeader(header, headerBytes);
-    bool ok = sink.append(headerBytes, SIDX_HEADER_SIZE);
-    for (uint32_t i = 0; i < SIDX_SECTION_COUNT && ok; i++) {
-        const void* data = parts[i] != nullptr ? static_cast<const void*>(parts[i]->begin()) : static_cast<const void*>(overflow.bytes.begin());
-        if (header.sectionSize[i] > 0) {
-            ok = sink.append(data, header.sectionSize[i]);
-        }
-    }
-    if (!ok) {
-        return failure.fail("the sink failed");
-    }
-    if (stats != nullptr) {
-        *stats = {};
-        stats->totalBytes = static_cast<uint32_t>(offset);
-        stats->header = header;
-        stats->keyCount = static_cast<uint32_t>(entries.size());
-        stats->ngCount = groupTotal;
-        for (uint32_t i = 0; i < pointCount; i++) {
-            if (points[i].name != nullptr) {
-                stats->namedPoints++;
-            } else {
-                stats->unnamedPoints++;
-            }
-        }
-        stats->overflowStrings = overflow.count;
-        stats->collapsedPairs = collapsed;
-        stats->categoryNotContiguous = notContiguous;
-    }
-    return true;
-}
-
 // ------------------------------------------------------------------------------------------------ reader
 
 uint32_t SearchIndexReader::readSection(SidxSection section, uint32_t offset, void* out, uint32_t size) {
diff --git a/Apps/Maps/main/Source/search/SearchRegion.cpp b/Apps/Maps/main/Source/search/SearchRegion.cpp
deleted file mode 100644
index 4110f74..0000000
--- a/Apps/Maps/main/Source/search/SearchRegion.cpp
+++ /dev/null
@@ -1,1154 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-#include "SearchRegion.h"
-
-#include "QueryParse.h"
-
-#include <algorithm>
-#include <cmath>
-#include <cstdio>
-#include <cstring>
-
-namespace maps {
-
-namespace {
-
-constexpr uint32_t NONE = UINT32_MAX;
-constexpr int TILE_UNITS = 4096;
-constexpr double PI_D = 3.14159265358979323846;
-constexpr size_t KEY_BUFFER = 2048;
-/** Fields of the index: a cluster's address count. */
-constexpr uint32_t MAX_CLUSTER_ADDRESSES = 0xFFFF;
-/** Lines are added up to this far outside a tile (the 100 m of matching plus the 60 m of the neighbours' vote). */
-constexpr double LINE_BUFFER_M = 160.0;
-
-uint64_t mix(uint64_t h) {
-    h ^= h >> 33;
-    h *= 0xff51afd7ed558ccdULL;
-    h ^= h >> 33;
-    h *= 0xc4ceb9fe1a85ec53ULL;
-    h ^= h >> 33;
-    return h;
-}
-
-uint64_t hashBytes(uint64_t h, const void* data, size_t size) {
-    const auto* p = static_cast<const uint8_t*>(data);
-    for (size_t i = 0; i < size; i++) {
-        h = (h ^ p[i]) * 0x100000001b3ULL;
-    }
-    return h;
-}
-
-uint64_t hashText(uint64_t h, const char* s) {
-    return s == nullptr ? hashBytes(h, "\1", 1) : hashBytes(h, s, strlen(s) + 1);
-}
-
-uint64_t hashInt(uint64_t h, int64_t v) {
-    return hashBytes(h, &v, sizeof(v));
-}
-
-bool sameText(const char* a, const char* b) {
-    if (a == nullptr || b == nullptr) {
-        return a == b;
-    }
-    return strcmp(a, b) == 0;
-}
-
-int32_t floorDiv(int32_t value, int32_t by) {
-    return value >= 0 ? value / by : -((-value + by - 1) / by);
-}
-
-bool startsWith(const char* s, const char* prefix) {
-    return strncmp(s, prefix, strlen(prefix)) == 0;
-}
-
-/** The characters of a UTF-8 word (data.py len() of a Python string). */
-size_t characterCount(const char* s, size_t bytes) {
-    size_t n = 0;
-    for (size_t i = 0; i < bytes; i++) {
-        if ((static_cast<uint8_t>(s[i]) & 0xC0) != 0x80) {
-            n++;
-        }
-    }
-    return n;
-}
-
-uint32_t tileKey(int x, int y) {
-    return static_cast<uint32_t>(x) << 16 | static_cast<uint32_t>(y);
-}
-
-} // namespace
-
-double metresPerUnitAtTileY(double tileY) {
-    const double n = PI_D * (1.0 - 2.0 * tileY / 16384.0);
-    const double lat = std::atan(std::sinh(n));
-    return 40075016.686 * std::cos(lat) / (16384.0 * 4096.0);
-}
-
-// ------------------------------------------------------------------------------------------------ HashIndex
-
-void HashIndex::clear() {
-    full = false;
-    values.clear();
-    hashes.clear();
-    used = 0;
-}
-
-void HashIndex::release() {
-    full = false;
-    values.release();
-    hashes.release();
-    used = 0;
-}
-
-void HashIndex::put(uint64_t hash, uint32_t value) {
-    const size_t mask = values.size() - 1;
-    size_t i = static_cast<size_t>(hash) & mask;
-    while (values[i] != NONE) {
-        i = (i + 1) & mask;
-    }
-    values[i] = value;
-    hashes[i] = hash;
-}
-
-void HashIndex::insert(uint64_t hash, uint32_t value) {
-    if (full) {
-        return;
-    }
-    if ((used + 1) * 2 > values.size()) {
-        // Both new arrays first: without memory for both the old table stays as it was (find() keeps working on it)
-        // and the index is full, which failed() reports
-        const size_t capacity = values.size() < 1024 ? 1024 : values.size() * 2;
-        GrowArray<uint32_t> grownValues;
-        GrowArray<uint64_t> grownHashes;
-        if (!grownValues.resize(capacity) || !grownHashes.resize(capacity)) {
-            full = true;
-            return;
-        }
-        for (size_t i = 0; i < capacity; i++) {
-            grownValues[i] = NONE;
-        }
-        grownValues.swap(values);
-        grownHashes.swap(hashes);
-        // The old table is in the grown* arrays now
-        for (size_t i = 0; i < grownValues.size(); i++) {
-            if (grownValues[i] != NONE) {
-                put(grownHashes[i], grownValues[i]);
-            }
-        }
-    }
-    put(hash, value);
-    used++;
-}
-
-// ------------------------------------------------------------------------------------------------ builder
-
-SearchRegionBuilder::SearchRegionBuilder() = default;
-SearchRegionBuilder::~SearchRegionBuilder() = default;
-
-bool SearchRegionBuilder::fail(const char* message) {
-    snprintf(errorText, sizeof(errorText), "%s", message);
-    return false;
-}
-
-bool SearchRegionBuilder::anyFailed() const {
-    return text.failed() || points.failed() || lines.failed() || linePoints.failed() || houses.failed() || labelIndex.failed() ||
-        nameIndex.failed() || pointIndex.failed() || lineIndex.failed() || houseIndex.failed() || tileIndex.failed() || labelOffsets.failed() ||
-        nameOffsets.failed() || clusters.failed() || streets.failed() || addressRecs.failed() || keyPool.failed() || keyOffsets.failed() ||
-        pointKeys.failed() || streetKeys.failed() || pointInputs.failed() || streetInputs.failed() || clusterInputs.failed() ||
-        addressInputs.failed() || keyPointers.failed() || pseudos.failed() || settlements.failed();
-}
-
-uint32_t SearchRegionBuilder::copyText(const char* s) {
-    if (s == nullptr) {
-        return EXTRACT_NONE;
-    }
-    const auto offset = static_cast<uint32_t>(text.size());
-    const size_t length = strlen(s);
-    // s may point into text (a settlement's name): grow first, so the pushes below never move it
-    const bool inside = s >= text.begin() && s < text.begin() + text.size();
-    const size_t from = inside ? static_cast<size_t>(s - text.begin()) : 0;
-    if (!text.reserve(text.size() + length + 1)) {
-        text.push(0);   // marks the failure (failed())
-        return offset;
-    }
-    const char* source = inside ? text.begin() + from : s;
-    for (size_t i = 0; i <= length; i++) {
-        text.push(source[i]);
-    }
-    return offset;
-}
-
-uint32_t SearchRegionBuilder::internLabel(const char* label) {
-    const uint64_t hash = mix(hashText(1469598103934665603ULL, label));
-    const uint32_t found = labelIndex.find(hash, [&](uint32_t id) { return strcmp(&text[labelOffsets[id]], label) == 0; });
-    if (found != NONE) {
-        return found;
-    }
-    const auto id = static_cast<uint32_t>(labelOffsets.size());
-    labelOffsets.push(copyText(label));
-    labelIndex.insert(hash, id);
-    return id;
-}
-
-uint32_t SearchRegionBuilder::internName(const char* name) {
-    const uint64_t hash = mix(hashText(1469598103934665603ULL, name));
-    const uint32_t found = nameIndex.find(hash, [&](uint32_t id) { return strcmp(&text[nameOffsets[id]], name) == 0; });
-    if (found != NONE) {
-        return found;
-    }
-    const auto id = static_cast<uint32_t>(nameOffsets.size());
-    nameOffsets.push(copyText(name));
-    nameIndex.insert(hash, id);
-    return id;
-}
-
-bool SearchRegionBuilder::mergeTile(const ExtractedTile& tile, uint32_t tileNumber) {
-    for (size_t i = 0; i < tile.points.size(); i++) {
-        const ExtractPoint& p = tile.points[i];
-        const char* name = tile.str(p.name);
-        const uint32_t labelId = internLabel(tile.str(p.label));
-        const uint64_t hash = mix(hashInt(hashInt(hashText(hashInt(1469598103934665603ULL, labelId), name), p.x), p.y));
-        const uint32_t found = pointIndex.find(hash, [&](uint32_t c) {
-            const Pt& q = points[c];
-            return q.label == labelId && q.x == p.x && q.y == p.y && sameText(textAt(q.name), name);
-        });
-        if (found != NONE) {
-            continue;
-        }
-        Pt q = {};
-        q.label = labelId;
-        q.name = copyText(name);
-        q.latin = copyText(tile.str(p.latin));
-        q.en = copyText(tile.str(p.en));
-        q.x = p.x;
-        q.y = p.y;
-        q.settlement = p.settlement;
-        q.useEn = p.useEn;
-        pointIndex.insert(hash, static_cast<uint32_t>(points.size()));
-        points.push(q);
-    }
-    for (size_t i = 0; i < tile.lines.size(); i++) {
-        const ExtractLine& l = tile.lines[i];
-        const uint32_t nameId = internName(tile.str(l.name));
-        const int32_t* xy = &tile.linePoints[2 * static_cast<size_t>(l.first)];
-        const uint64_t hash = mix(hashBytes(hashInt(1469598103934665603ULL, nameId), xy, 2 * sizeof(int32_t) * l.count));
-        const uint32_t found = lineIndex.find(hash, [&](uint32_t c) {
-            const Ln& q = lines[c];
-            return q.nameId == nameId && q.count == l.count && memcmp(&linePoints[2 * static_cast<size_t>(q.first)], xy, 2 * sizeof(int32_t) * l.count) == 0;
-        });
-        if (found != NONE) {
-            continue;
-        }
-        Ln q = {};
-        q.nameId = nameId;
-        q.latin = copyText(tile.str(l.latin));
-        q.first = static_cast<uint32_t>(linePoints.size() / 2);
-        q.count = l.count;
-        q.cluster = NONE;
-        q.pathClass = l.pathClass;
-        q.minX = q.maxX = xy[0];
-        q.minY = q.maxY = xy[1];
-        for (uint32_t k = 0; k < l.count; k++) {
-            q.minX = std::min(q.minX, xy[2 * k]);
-            q.maxX = std::max(q.maxX, xy[2 * k]);
-            q.minY = std::min(q.minY, xy[2 * k + 1]);
-            q.maxY = std::max(q.maxY, xy[2 * k + 1]);
-            linePoints.push(xy[2 * k]);
-            linePoints.push(xy[2 * k + 1]);
-        }
-        lineIndex.insert(hash, static_cast<uint32_t>(lines.size()));
-        lines.push(q);
-    }
-    for (size_t i = 0; i < tile.houses.size(); i++) {
-        const ExtractHouse& h = tile.houses[i];
-        const char* number = tile.str(h.text);
-        const uint64_t hash = mix(hashInt(hashInt(hashText(1469598103934665603ULL, number), h.x), h.y));
-        const uint32_t found = houseIndex.find(hash, [&](uint32_t c) {
-            const Hs& q = houses[c];
-            return q.x == h.x && q.y == h.y && strcmp(&text[q.text], number) == 0;
-        });
-        if (found != NONE) {
-            // data.py: the copy inside its own tile wins
-            if (h.inside != 0 && houses[found].inside == 0) {
-                houses[found].inside = 1;
-                houses[found].tile = tileNumber;
-                houses[found].local = static_cast<uint32_t>(i);
-            }
-            continue;
-        }
-        Hs q = {};
-        q.text = copyText(number);
-        q.x = h.x;
-        q.y = h.y;
-        q.tile = tileNumber;
-        q.local = static_cast<uint32_t>(i);
-        q.inside = h.inside;
-        q.cluster = NONE;
-        q.village = NONE;
-        houseIndex.insert(hash, static_cast<uint32_t>(houses.size()));
-        houses.push(q);
-    }
-    return !anyFailed();
-}
-
-bool SearchRegionBuilder::addTile(MvtDecoder& decoder, ByteInput* input, int tileX, int tileY) {
-    if (!extractor.extract(decoder, input, tileX, tileY, tileBuffer)) {
-        return fail("cannot read a tile");
-    }
-    const uint64_t hash = mix(tileKey(tileX, tileY));
-    const auto tileNumber = static_cast<uint32_t>(tiles.size());
-    tileIndex.insert(hash, tileNumber);
-    tiles.push({ tileX, tileY });
-    statistics.refOnlyLines += tileBuffer.refOnlyLines;
-    statistics.junkPoisSkipped += tileBuffer.junkPois;
-    return mergeTile(tileBuffer, tileNumber) || fail("no memory");
-}
-
-HouseView SearchRegionBuilder::house(size_t index) const {
-    const Hs& h = houses[index];
-    HouseView v = {};
-    v.text = &text[h.text];
-    v.x = h.x;
-    v.y = h.y;
-    v.tier = static_cast<AddressTier>(h.tier);
-    v.streetM = h.streetM;
-    v.villageStyle = h.villageStyle != 0;
-    if (h.cluster != NONE) {
-        v.street = textAt(nameOffsets[streets[clusters[h.cluster].street].nameId]);
-    }
-    if (h.village != NONE) {
-        v.village = textAt(nameOffsets[settlements[h.village].nameId]);
-    }
-    return v;
-}
-
-// ------------------------------------------------------------------------------------------------ clusters
-
-namespace {
-
-struct CellEntry {
-    uint32_t nameId;
-    int32_t cx, cy;
-    uint32_t line;
-};
-
-struct LineRef {
-    uint32_t nameId;
-    uint32_t root;
-    uint32_t line;
-};
-
-struct Group {
-    uint32_t nameId;
-    uint32_t begin;
-    uint32_t end;
-    int32_t minX, minY;
-};
-
-} // namespace
-
-bool SearchRegionBuilder::makeClusters(double metresPerUnit) {
-    const size_t count = lines.size();
-    const auto cell = std::max<int32_t>(1, static_cast<int32_t>(150.0 / metresPerUnit));
-    GrowArray<uint32_t> parent;
-    parent.resize(count);
-    for (size_t i = 0; i < count; i++) {
-        parent[i] = static_cast<uint32_t>(i);
-    }
-    auto find = [&](uint32_t x) {
-        while (parent[x] != x) {
-            parent[x] = parent[parent[x]];
-            x = parent[x];
-        }
-        return x;
-    };
-    HashIndex cells;
-    GrowArray<CellEntry> entries;
-    auto cellHash = [](uint32_t nameId, int32_t cx, int32_t cy) {
-        return mix((static_cast<uint64_t>(nameId) * 0x9E3779B97F4A7C15ULL) ^ (static_cast<uint64_t>(static_cast<uint32_t>(cx)) << 32 | static_cast<uint32_t>(cy)));
-    };
-    for (size_t i = 0; i < count; i++) {
-        const Ln& line = lines[i];
-        int32_t previousX = INT32_MIN;
-        int32_t previousY = INT32_MIN;
-        for (uint32_t k = 0; k < line.count; k++) {
-            const int32_t cx = floorDiv(linePoints[2 * (static_cast<size_t>(line.first) + k)], cell);
-            const int32_t cy = floorDiv(linePoints[2 * (static_cast<size_t>(line.first) + k) + 1], cell);
-            if (cx == previousX && cy == previousY) {
-                continue;
-            }
-            previousX = cx;
-            previousY = cy;
-            for (int dx = -1; dx <= 1; dx++) {
-                for (int dy = -1; dy <= 1; dy++) {
-                    const uint32_t found = cells.find(cellHash(line.nameId, cx + dx, cy + dy), [&](uint32_t e) {
-                        return entries[e].nameId == line.nameId && entries[e].cx == cx + dx && entries[e].cy == cy + dy;
-                    });
-                    if (found != NONE) {
-                        const uint32_t a = find(static_cast<uint32_t>(i));
-                        const uint32_t b = find(entries[found].line);
-                        if (a != b) {
-                            parent[a] = b;
-                        }
-                    }
-                }
-            }
-            const uint64_t hash = cellHash(line.nameId, cx, cy);
-            if (cells.find(hash, [&](uint32_t e) { return entries[e].nameId == line.nameId && entries[e].cx == cx && entries[e].cy == cy; }) == NONE) {
-                cells.insert(hash, static_cast<uint32_t>(entries.size()));
-                entries.push({ line.nameId, cx, cy, static_cast<uint32_t>(i) });
-            }
-        }
-    }
-    cells.release();
-    entries.release();
-    GrowArray<LineRef> refs;
-    refs.reserve(count);
-    for (size_t i = 0; i < count; i++) {
-        refs.push({ lines[i].nameId, find(static_cast<uint32_t>(i)), static_cast<uint32_t>(i) });
-    }
-    std::sort(refs.begin(), refs.end(), [](const LineRef& a, const LineRef& b) {
-        if (a.nameId != b.nameId) return a.nameId < b.nameId;
-        if (a.root != b.root) return a.root < b.root;
-        return a.line < b.line;
-    });
-    GrowArray<Group> groups;
-    for (size_t i = 0; i < refs.size();) {
-        size_t j = i;
-        Group g = { refs[i].nameId, static_cast<uint32_t>(i), 0, INT32_MAX, INT32_MAX };
-        while (j < refs.size() && refs[j].nameId == refs[i].nameId && refs[j].root == refs[i].root) {
-            const Ln& line = lines[refs[j].line];
-            const int32_t fx = linePoints[2 * static_cast<size_t>(line.first)];
-            const int32_t fy = linePoints[2 * static_cast<size_t>(line.first) + 1];
-            if (fx < g.minX || (fx == g.minX && fy < g.minY)) {
-                g.minX = fx;
-                g.minY = fy;
-            }
-            j++;
-        }
-        g.end = static_cast<uint32_t>(j);
-        groups.push(g);
-        i = j;
-    }
-    // Streets in the byte order of their names, clusters of a street by their smallest first vertex
-    std::sort(groups.begin(), groups.end(), [&](const Group& a, const Group& b) {
-        if (a.nameId != b.nameId) return strcmp(&text[nameOffsets[a.nameId]], &text[nameOffsets[b.nameId]]) < 0;
-        if (a.minX != b.minX) return a.minX < b.minX;
-        if (a.minY != b.minY) return a.minY < b.minY;
-        return a.begin < b.begin;
-    });
-    clusters.clear();
-    streets.clear();
-    for (const Group& g : groups) {
-        if (streets.size() == 0 || streets[streets.size() - 1].nameId != g.nameId) {
-            Street s = {};
-            s.nameId = g.nameId;
-            s.latin = EXTRACT_NONE;
-            s.en = EXTRACT_NONE;
-            s.firstCluster = static_cast<uint32_t>(clusters.size());
-            streets.push(s);
-        }
-        Street& street = streets[streets.size() - 1];
-        Cluster c = {};
-        c.street = static_cast<uint32_t>(streets.size() - 1);
-        c.minX = c.minY = INT32_MAX;
-        c.maxX = c.maxY = INT32_MIN;
-        double sumX = 0;
-        double sumY = 0;
-        uint64_t total = 0;
-        for (uint32_t r = g.begin; r < g.end; r++) {
-            Ln& line = lines[refs[r].line];
-            line.cluster = static_cast<uint32_t>(clusters.size());
-            if (street.latin == EXTRACT_NONE && line.latin != EXTRACT_NONE) {
-                street.latin = line.latin;
-            }
-            for (uint32_t k = 0; k < line.count; k++) {
-                const int32_t x = linePoints[2 * (static_cast<size_t>(line.first) + k)];
-                const int32_t y = linePoints[2 * (static_cast<size_t>(line.first) + k) + 1];
-                sumX += x;
-                sumY += y;
-                total++;
-                c.minX = std::min(c.minX, x);
-                c.maxX = std::max(c.maxX, x);
-                c.minY = std::min(c.minY, y);
-                c.maxY = std::max(c.maxY, y);
-            }
-        }
-        const double cx = sumX / static_cast<double>(total);
-        const double cy = sumY / static_cast<double>(total);
-        double bestD = 0;
-        bool have = false;
-        for (uint32_t r = g.begin; r < g.end; r++) {
-            const Ln& line = lines[refs[r].line];
-            for (uint32_t k = 0; k < line.count; k++) {
-                const int32_t x = linePoints[2 * (static_cast<size_t>(line.first) + k)];
-                const int32_t y = linePoints[2 * (static_cast<size_t>(line.first) + k) + 1];
-                const double d = (x - cx) * (x - cx) + (y - cy) * (y - cy);
-                if (!have || d < bestD || (d == bestD && (x < c.repX || (x == c.repX && y < c.repY)))) {
-                    have = true;
-                    bestD = d;
-                    c.repX = x;
-                    c.repY = y;
-                }
-            }
-        }
-        street.clusterCount++;
-        clusters.push(c);
-    }
-    return !(clusters.failed() || streets.failed() || parent.failed() || refs.failed() || groups.failed());
-}
-
-// ------------------------------------------------------------------------------------------------ matching
-
-bool SearchRegionBuilder::matchHouses(const RegionConfig& config, double metresPerUnit, bool villageMode, bool slashSecond) {
-    const size_t tileCount = tiles.size();
-    const size_t houseCount = houses.size();
-    // Own houses per tile
-    GrowArray<uint32_t> houseStart;
-    GrowArray<uint32_t> houseOrder;
-    houseStart.resize(tileCount + 1);
-    for (size_t i = 0; i < houseCount; i++) {
-        houseStart[houses[i].tile + 1]++;
-    }
-    for (size_t t = 0; t < tileCount; t++) {
-        houseStart[t + 1] += houseStart[t];
-    }
-    houseOrder.resize(houseCount);
-    {
-        GrowArray<uint32_t> fill;
-        fill.resize(tileCount);
-        for (size_t i = 0; i < houseCount; i++) {
-            const uint32_t t = houses[i].tile;
-            houseOrder[houseStart[t] + fill[t]++] = static_cast<uint32_t>(i);
-        }
-    }
-    // A tile's houses in the order of its own extract (the order a streaming build sees them in)
-    for (size_t t = 0; t < tileCount; t++) {
-        std::sort(&houseOrder[houseStart[t]], &houseOrder[houseStart[t]] + (houseStart[t + 1] - houseStart[t]),
-                  [&](uint32_t a, uint32_t b) { return houses[a].local < houses[b].local; });
-    }
-    // Lines per tile, with the buffer
-    const auto lineBuffer = static_cast<int32_t>(LINE_BUFFER_M / metresPerUnit) + 1;
-    GrowArray<uint32_t> lineStart;
-    GrowArray<uint32_t> lineOrder;
-    lineStart.resize(tileCount + 1);
-    auto forTiles = [&](const Ln& line, auto visit) {
-        const int32_t x0 = floorDiv(line.minX - lineBuffer, TILE_UNITS);
-        const int32_t x1 = floorDiv(line.maxX + lineBuffer, TILE_UNITS);
-        const int32_t y0 = floorDiv(line.minY - lineBuffer, TILE_UNITS);
-        const int32_t y1 = floorDiv(line.maxY + lineBuffer, TILE_UNITS);
-        for (int32_t tx = x0; tx <= x1; tx++) {
-            for (int32_t ty = y0; ty <= y1; ty++) {
-                const uint32_t t = tileIndex.find(mix(tileKey(tx, ty)), [&](uint32_t c) { return tiles[c].x == tx && tiles[c].y == ty; });
-                if (t != NONE) {
-                    visit(t);
-                }
-            }
-        }
-    };
-    for (size_t i = 0; i < lines.size(); i++) {
-        if (lines[i].pathClass != 0 && !config.matchPathLines) {
-            continue;
-        }
-        forTiles(lines[i], [&](uint32_t t) { lineStart[t + 1]++; });
-    }
-    for (size_t t = 0; t < tileCount; t++) {
-        lineStart[t + 1] += lineStart[t];
-    }
-    lineOrder.resize(lineStart[tileCount]);
-    {
-        GrowArray<uint32_t> fill;
-        fill.resize(tileCount);
-        for (size_t i = 0; i < lines.size(); i++) {
-            if (lines[i].pathClass != 0 && !config.matchPathLines) {
-                continue;
-            }
-            forTiles(lines[i], [&](uint32_t t) { lineOrder[lineStart[t] + fill[t]++] = static_cast<uint32_t>(i); });
-        }
-    }
-    settlementPseudo.resize(settlements.size());
-    for (size_t i = 0; i < settlementPseudo.size(); i++) {
-        settlementPseudo[i] = NONE;
-    }
-    nameStreet.resize(nameOffsets.size());
-    for (size_t i = 0; i < nameStreet.size(); i++) {
-        nameStreet[i] = NONE;
-    }
-    for (size_t i = 0; i < streets.size(); i++) {
-        nameStreet[streets[i].nameId] = static_cast<uint32_t>(i);
-    }
-
-    GrowArray<uint32_t> contextOf;
-    for (size_t t = 0; t < tileCount; t++) {
-        if (houseStart[t + 1] == houseStart[t]) {
-            continue;
-        }
-        const double mpu = metresPerUnitAtTileY(tiles[t].y + 0.5);
-        const int32_t rx0 = tiles[t].x * TILE_UNITS;
-        const int32_t ry0 = tiles[t].y * TILE_UNITS;
-        const int32_t rx1 = rx0 + TILE_UNITS - 1;
-        const int32_t ry1 = ry0 + TILE_UNITS - 1;
-        matcher.begin(mpu);
-        matcher.clipToTile(tiles[t].x, tiles[t].y);
-        for (uint32_t k = lineStart[t]; k < lineStart[t + 1]; k++) {
-            const Ln& line = lines[lineOrder[k]];
-            matcher.addLine(line.cluster, &linePoints[2 * static_cast<size_t>(line.first)], line.count);
-        }
-        if (villageMode) {
-            const auto placeBuffer = static_cast<int32_t>(AddressMatcher::PLACE_M / mpu) + 1;
-            for (size_t s = 0; s < settlements.size(); s++) {
-                const Pt& p = points[settlements[s].point];
-                if (p.x >= rx0 - placeBuffer && p.x <= rx1 + placeBuffer && p.y >= ry0 - placeBuffer && p.y <= ry1 + placeBuffer) {
-                    matcher.addPlace(static_cast<uint32_t>(s), static_cast<PlaceClass>(settlements[s].placeClass), p.x, p.y);
-                }
-            }
-        }
-        auto streetNumberOf = [&](const char* number) { return houseVoteNumber(number, slashSecond && config.voteSlashSecond); };
-        const uint32_t own = houseStart[t + 1] - houseStart[t];
-        for (uint32_t k = houseStart[t]; k < houseStart[t + 1]; k++) {
-            Hs& h = houses[houseOrder[k]];
-            const char* number = &text[h.text];
-            const bool villageStyle = villageMode && houseNumberStyle(number).plain;
-            h.villageStyle = villageStyle ? 1 : 0;
-            matcher.addHouse(h.x, h.y, streetNumberOf(number), villageStyle);
-        }
-        // The neighbours' houses near the tile edge take part in the vote
-        const auto voteBuffer = static_cast<int32_t>(AddressMatcher::VOTE_M / mpu) + 1;
-        for (int dx = -1; dx <= 1; dx++) {
-            for (int dy = -1; dy <= 1; dy++) {
-                if (dx == 0 && dy == 0) {
-                    continue;
-                }
-                const int nx = tiles[t].x + dx;
-                const int ny = tiles[t].y + dy;
-                const uint32_t n = tileIndex.find(mix(tileKey(nx, ny)), [&](uint32_t c) { return tiles[c].x == nx && tiles[c].y == ny; });
-                if (n == NONE) {
-                    continue;
-                }
-                for (uint32_t k = houseStart[n]; k < houseStart[n + 1]; k++) {
-                    const Hs& h = houses[houseOrder[k]];
-                    if (h.x >= rx0 - voteBuffer && h.x <= rx1 + voteBuffer && h.y >= ry0 - voteBuffer && h.y <= ry1 + voteBuffer) {
-                        matcher.addHouse(h.x, h.y, streetNumberOf(&text[h.text]), false);
-                    }
-                }
-            }
-        }
-        if (!matcher.run()) {
-            return fail("no memory for the house matching");
-        }
-        for (uint32_t k = 0; k < own; k++) {
-            const uint32_t index = houseOrder[houseStart[t] + k];
-            Hs& h = houses[index];
-            const AddressMatch& m = matcher.result(k);
-            h.tier = static_cast<uint8_t>(m.tier);
-            h.cluster = m.tier == AddressTier::None ? NONE : m.street;
-            h.streetM = m.streetM;
-            h.village = (h.villageStyle != 0 && m.villages[0] != NONE) ? m.villages[0] : NONE;
-            if (h.cluster != NONE) {
-                addressRecs.push({ h.cluster, index, static_cast<uint8_t>(m.tier == AddressTier::LowStreet ? ADDRESS_LOW : 0) });
-                if (m.tier == AddressTier::Street) {
-                    statistics.pathStreet50++;
-                } else {
-                    statistics.pathStreet100++;
-                }
-                if (h.village != NONE) {
-                    statistics.alsoVillage++;
-                }
-            } else if (h.village != NONE) {
-                statistics.pathVillage++;
-            } else {
-                statistics.pathNone++;
-            }
-            if (h.village != NONE) {
-                uint32_t& pseudo = settlementPseudo[h.village];
-                if (pseudo == NONE) {
-                    const Settlement& s = settlements[h.village];
-                    uint32_t street = nameStreet[s.nameId];
-                    if (street == NONE) {
-                        const Pt& p = points[s.point];
-                        Street created = {};
-                        created.nameId = s.nameId;
-                        created.latin = p.latin;
-                        created.en = p.en;
-                        created.useEn = 1;
-                        street = static_cast<uint32_t>(streets.size());
-                        nameStreet[s.nameId] = street;
-                        streets.push(created);
-                    }
-                    pseudo = static_cast<uint32_t>(pseudos.size());
-                    pseudos.push({ street, h.village });
-                }
-                addressRecs.push({ static_cast<uint32_t>(clusters.size()) + pseudo, index, ADDRESS_VILLAGE });
-            }
-        }
-    }
-    matcher.release();
-    statistics.pseudoStreets = static_cast<uint32_t>(pseudos.size());
-    return !anyFailed();
-}
-
-// ------------------------------------------------------------------------------------------------ keys
-
-SearchRegionBuilder::KeyRef SearchRegionBuilder::makeKeys(const char* name, const char* latin, const char* en, bool useEn, Translit profile) {
-    KeyRef ref = {};
-    keyMaker.make(name, latin, en, useEn, profile);
-    auto copy = [&](const char* key) {
-        const auto offset = static_cast<uint32_t>(keyPool.size());
-        for (const char* c = key;; c++) {
-            keyPool.push(*c);
-            if (*c == '\0') {
-                break;
-            }
-        }
-        return offset;
-    };
-    ref.sortKey = copy(keyMaker.sortKey());
-    ref.first = static_cast<uint32_t>(keyOffsets.size());
-    for (uint32_t i = 0; i < keyMaker.count(); i++) {
-        keyOffsets.push(copy(keyMaker.key(i)));
-    }
-    ref.count = keyMaker.count();
-    return ref;
-}
-
-// ------------------------------------------------------------------------------------------------ KeyMaker
-
-void KeyMaker::sortKeyOf(const char* name, Translit profile, char* out, size_t outSize) {
-    if (!hasNonLatin(name)) {
-        foldLatin(name, out, outSize);
-    } else {
-        transliterate(name, profile, out, outSize);
-    }
-}
-
-bool KeyMaker::has(const char* key) const {
-    for (size_t i = 0; i < offsets.size(); i++) {
-        if (strcmp(&pool[offsets[i]], key) == 0) {
-            return true;
-        }
-    }
-    return false;
-}
-
-void KeyMaker::add(const char* key) {
-    offsets.push(static_cast<uint32_t>(pool.size()));
-    for (const char* c = key;; c++) {
-        pool.push(*c);
-        if (*c == '\0') {
-            break;
-        }
-    }
-}
-
-bool KeyMaker::make(const char* name, const char* latin, const char* en, bool useEn, Translit profile) {
-    pool.clear();
-    offsets.clear();
-    // The sort key first in the pool (offset 0), not one of the keys
-    sortKeyOf(name, profile, scratch[4], BUFFER);
-    for (const char* c = scratch[4];; c++) {
-        pool.push(*c);
-        if (*c == '\0') {
-            break;
-        }
-    }
-    // fold.search_keys
-    int n = 0;
-    if (!hasNonLatin(name)) {
-        foldLatin(name, scratch[n++], BUFFER);
-        if (latin != nullptr && !hasNonLatin(latin)) {
-            foldLatin(latin, scratch[n++], BUFFER);
-        }
-    } else {
-        transliterate(name, profile, scratch[n++], BUFFER);
-        foldOriginal(name, scratch[n++], BUFFER);
-        if (latin != nullptr) {
-            foldLatin(latin, scratch[n++], BUFFER);
-        }
-    }
-    if (useEn && en != nullptr && !hasNonLatin(en)) {
-        foldLatin(en, scratch[n++], BUFFER);
-    }
-    for (int i = 0; i < n; i++) {
-        if (scratch[i][0] != '\0' && !has(scratch[i])) {
-            add(scratch[i]);
-        }
-    }
-    // fold.suffix_keys of each base key: the text from each later word of at least 3 characters
-    const size_t baseCount = offsets.size();
-    for (size_t b = 0; b < baseCount; b++) {
-        // The pool may move while keys are added: work on a copy
-        strncpy(scratch[4], &pool[offsets[b]], BUFFER - 1);
-        scratch[4][BUFFER - 1] = '\0';
-        const char* word = scratch[4];
-        bool first = true;
-        while (true) {
-            const char* space = strchr(word, ' ');
-            const size_t length = space != nullptr ? static_cast<size_t>(space - word) : strlen(word);
-            if (!first && characterCount(word, length) >= 3 && !has(word)) {
-                add(word);
-            }
-            first = false;
-            if (space == nullptr) {
-                break;
-            }
-            word = space + 1;
-        }
-    }
-    return !pool.failed() && !offsets.failed();
-}
-
-// ------------------------------------------------------------------------------------------------ assembly
-
-bool SearchRegionBuilder::assemble(const RegionConfig& config) {
-    const size_t realClusters = clusters.size();
-    const size_t unified = realClusters + pseudos.size();
-    // Streets in the byte order of their names (the settlements' own streets were added at the end)
-    GrowArray<uint32_t> streetOrder;
-    GrowArray<uint32_t> streetRank;
-    for (size_t i = 0; i < streets.size(); i++) {
-        streetOrder.push(static_cast<uint32_t>(i));
-    }
-    std::sort(streetOrder.begin(), streetOrder.end(), [&](uint32_t a, uint32_t b) {
-        return strcmp(&text[nameOffsets[streets[a].nameId]], &text[nameOffsets[streets[b].nameId]]) < 0;
-    });
-    streetRank.resize(streets.size());
-    for (size_t k = 0; k < streetOrder.size(); k++) {
-        streetRank[streetOrder[k]] = static_cast<uint32_t>(k);
-    }
-    // Pseudo clusters in street order, then in the order of their settlements (the points' order)
-    GrowArray<uint32_t> pseudoOrder;
-    for (size_t i = 0; i < pseudos.size(); i++) {
-        pseudoOrder.push(static_cast<uint32_t>(i));
-    }
-    std::sort(pseudoOrder.begin(), pseudoOrder.end(), [&](uint32_t a, uint32_t b) {
-        if (pseudos[a].street != pseudos[b].street) return streetRank[pseudos[a].street] < streetRank[pseudos[b].street];
-        return pseudos[a].settlement < pseudos[b].settlement;
-    });
-    // Output order of the clusters: per street, the real ones, then the places'
-    GrowArray<uint32_t> finalOf;
-    finalOf.resize(unified);
-    GrowArray<uint32_t> unifiedAt;
-    size_t cursor = 0;
-    for (size_t k = 0; k < streetOrder.size(); k++) {
-        const uint32_t s = streetOrder[k];
-        for (uint32_t c = 0; c < streets[s].clusterCount; c++) {
-            const uint32_t id = streets[s].firstCluster + c;
-            finalOf[id] = static_cast<uint32_t>(unifiedAt.size());
-            unifiedAt.push(id);
-        }
-        while (cursor < pseudoOrder.size() && pseudos[pseudoOrder[cursor]].street == s) {
-            const auto id = static_cast<uint32_t>(realClusters + pseudoOrder[cursor]);
-            finalOf[id] = static_cast<uint32_t>(unifiedAt.size());
-            unifiedAt.push(id);
-            cursor++;
-        }
-    }
-    // Addresses per output cluster (counting sort), capped at the field's width
-    GrowArray<uint32_t> start;
-    start.resize(unified + 1);
-    for (const AddressRec& r : addressRecs) {
-        start[finalOf[r.cluster] + 1]++;
-    }
-    for (size_t i = 0; i < unified; i++) {
-        start[i + 1] += start[i];
-    }
-    GrowArray<uint32_t> order;
-    order.resize(addressRecs.size());
-    {
-        GrowArray<uint32_t> fill;
-        fill.resize(unified);
-        for (size_t i = 0; i < addressRecs.size(); i++) {
-            const uint32_t f = finalOf[addressRecs[i].cluster];
-            order[start[f] + fill[f]++] = static_cast<uint32_t>(i);
-        }
-    }
-    addressInputs.clear();
-    clusterInputs.clear();
-    GrowArray<uint32_t> addressFirst;
-    GrowArray<uint32_t> numberOffsets;
-    for (size_t f = 0; f < unified; f++) {
-        const uint32_t id = unifiedAt[f];
-        SearchClusterInput c = {};
-        if (id < realClusters) {
-            const Cluster& k = clusters[id];
-            c.repX = k.repX;
-            c.repY = k.repY;
-            c.minX = k.minX;
-            c.minY = k.minY;
-            c.maxX = k.maxX;
-            c.maxY = k.maxY;
-        } else {
-            const Pt& p = points[settlements[pseudos[id - realClusters].settlement].point];
-            c.repX = c.minX = c.maxX = p.x;
-            c.repY = c.minY = c.maxY = p.y;
-        }
-        addressFirst.push(static_cast<uint32_t>(addressInputs.size()));
-        uint32_t taken = 0;
-        for (uint32_t k = start[f]; k < start[f + 1]; k++) {
-            if (taken >= MAX_CLUSTER_ADDRESSES) {
-                statistics.droppedAddresses++;
-                continue;
-            }
-            const AddressRec& r = addressRecs[order[k]];
-            const Hs& h = houses[r.house];
-            // The text pointer is set when the pool is final (below): keep the offset for now
-            addressInputs.push({ nullptr, h.x, h.y, r.flags });
-            numberOffsets.push(h.text);
-            taken++;
-        }
-        c.addressCount = taken;
-        clusterInputs.push(c);
-    }
-    for (size_t f = 0; f < unified; f++) {
-        clusterInputs[f].addresses = clusterInputs[f].addressCount > 0 ? &addressInputs[addressFirst[f]] : nullptr;
-    }
-    statistics.addresses = static_cast<uint32_t>(addressInputs.size());
-    // Number texts: the offsets become pointers (the pool does not grow any more)
-    for (size_t i = 0; i < addressInputs.size(); i++) {
-        addressInputs[i].number = &text[numberOffsets[i]];
-    }
-
-    // Streets and their keys
-    streetInputs.clear();
-    streetKeys.clear();
-    keyPool.clear();
-    keyOffsets.clear();
-    uint32_t clusterAt = 0;
-    for (size_t k = 0; k < streetOrder.size(); k++) {
-        const uint32_t s = streetOrder[k];
-        const Street& street = streets[s];
-        const KeyRef keys = makeKeys(&text[nameOffsets[street.nameId]], textAt(street.latin), textAt(street.en), street.useEn != 0, config.profile);
-        streetKeys.push(keys);
-        SearchStreetInput in = {};
-        in.name = &text[nameOffsets[street.nameId]];
-        in.keyCount = keys.count;
-        uint32_t total = street.clusterCount;
-        for (size_t p = 0; p < pseudoOrder.size(); p++) {
-            if (pseudos[pseudoOrder[p]].street == s) {
-                total++;
-            }
-        }
-        in.clusterCount = total;
-        in.clusters = total > 0 ? &clusterInputs[clusterAt] : nullptr;
-        clusterAt += total;
-        streetInputs.push(in);
-    }
-    // Points and their keys
-    pointInputs.clear();
-    pointKeys.clear();
-    keyShare.clear();
-    for (size_t i = 0; i < points.size(); i++) {
-        const Pt& p = points[i];
-        KeyRef keys = {};
-        keys.sortKey = NONE;
-        if (p.name != EXTRACT_NONE) {
-            const char* name = &text[p.name];
-            const uint64_t hash = mix(hashInt(hashText(hashText(hashText(1469598103934665603ULL, name), textAt(p.latin)), textAt(p.en)), p.useEn));
-            const uint32_t found = keyShare.find(hash, [&](uint32_t c) {
-                const Pt& q = points[c];
-                return q.useEn == p.useEn && sameText(textAt(q.name), name) && sameText(textAt(q.latin), textAt(p.latin)) && sameText(textAt(q.en), textAt(p.en));
-            });
-            if (found != NONE) {
-                keys = pointKeys[found];
-            } else {
-                keys = makeKeys(name, textAt(p.latin), textAt(p.en), p.useEn != 0, config.profile);
-                keyShare.insert(hash, static_cast<uint32_t>(i));
-            }
-        }
-        pointKeys.push(keys);
-    }
-    // Category names that are not ASCII get a key of their own
-    GrowArray<uint32_t> categoryNameOffsets;
-    GrowArray<uint32_t> categoryKeyOffsets;
-    for (size_t i = 0; i < labelOffsets.size(); i++) {
-        const char* label = &text[labelOffsets[i]];
-        if (!startsWith(label, "poi/")) {
-            continue;
-        }
-        const char* part = label + 4;
-        for (int k = 0; k < 2 && part != nullptr; k++) {
-            const char* slash = strchr(part, '/');
-            const size_t length = slash != nullptr ? static_cast<size_t>(slash - part) : strlen(part);
-            char display[200];
-            const size_t n = std::min(length, sizeof(display) - 1);
-            bool ascii = true;
-            for (size_t c = 0; c < n; c++) {
-                display[c] = part[c] == '_' ? ' ' : part[c];
-                ascii = ascii && static_cast<uint8_t>(part[c]) < 0x80;
-            }
-            display[n] = '\0';
-            part = slash != nullptr ? slash + 1 : nullptr;
-            if (ascii) {
-                continue;
-            }
-            bool known = false;
-            for (size_t c = 0; c < categoryNameOffsets.size(); c++) {
-                known = known || strcmp(&keyPool[categoryNameOffsets[c]], display) == 0;
-            }
-            if (known) {
-                continue;
-            }
-            categoryNameOffsets.push(static_cast<uint32_t>(keyPool.size()));
-            for (const char* c = display;; c++) {
-                keyPool.push(*c);
-                if (*c == '\0') {
-                    break;
-                }
-            }
-            KeyMaker::sortKeyOf(display, config.profile, categoryScratch, sizeof(categoryScratch));
-            categoryKeyOffsets.push(static_cast<uint32_t>(keyPool.size()));
-            for (const char* c = categoryScratch;; c++) {
-                keyPool.push(*c);
-                if (*c == '\0') {
-                    break;
-                }
-            }
-        }
-    }
-    if (anyFailed()) {
-        return false;
-    }
-    // The pools are final: pointers
-    keyPointers.clear();
-    for (size_t i = 0; i < keyOffsets.size(); i++) {
-        keyPointers.push(&keyPool[keyOffsets[i]]);
-    }
-    for (size_t i = 0; i < points.size(); i++) {
-        const Pt& p = points[i];
-        SearchPointInput in = {};
-        in.label = &text[labelOffsets[p.label]];
-        in.x = p.x;
-        in.y = p.y;
-        if (p.name != EXTRACT_NONE) {
-            in.name = &text[p.name];
-            in.sortKey = &keyPool[pointKeys[i].sortKey];
-            in.keys = pointKeys[i].count > 0 ? &keyPointers[pointKeys[i].first] : nullptr;
-            in.keyCount = pointKeys[i].count;
-        }
-        pointInputs.push(in);
-    }
-    for (size_t s = 0; s < streets.size(); s++) {
-        streetInputs[s].sortKey = &keyPool[streetKeys[s].sortKey];
-        streetInputs[s].keys = streetKeys[s].count > 0 ? &keyPointers[streetKeys[s].first] : nullptr;
-    }
-    categoryNames.clear();
-    categoryKeys.clear();
-    for (size_t i = 0; i < categoryNameOffsets.size(); i++) {
-        categoryNames.push(&keyPool[categoryNameOffsets[i]]);
-        categoryKeys.push(&keyPool[categoryKeyOffsets[i]]);
-    }
-    searchInput = {};
-    searchInput.points = pointInputs.begin();
-    searchInput.pointCount = static_cast<uint32_t>(pointInputs.size());
-    searchInput.streets = streetInputs.begin();
-    searchInput.streetCount = static_cast<uint32_t>(streetInputs.size());
-    searchInput.slashSecond = statistics.slashSecond;
-    searchInput.categoryNames = categoryNames.begin();
-    searchInput.categoryKeys = categoryKeys.begin();
-    searchInput.categoryOverrides = static_cast<uint32_t>(categoryNames.size());
-    return !anyFailed();
-}
-
-bool SearchRegionBuilder::buildSearchInput(const RegionConfig& config) {
-    errorText[0] = '\0';
-    if (tiles.size() == 0) {
-        return fail("no tiles");
-    }
-    int minY = tiles[0].y;
-    int maxY = tiles[0].y;
-    for (const TileRef& t : tiles) {
-        minY = std::min(minY, t.y);
-        maxY = std::max(maxY, t.y);
-    }
-    const double mpu = config.metresPerUnit > 0 ? config.metresPerUnit : metresPerUnitAtTileY((minY + maxY + 1) / 2.0);
-    RegionStats& st = statistics;
-    st.tiles = static_cast<uint32_t>(tiles.size());
-    st.lines = static_cast<uint32_t>(lines.size());
-    st.houses = static_cast<uint32_t>(houses.size());
-    for (const Pt& p : points) {
-        const char* label = &text[labelOffsets[p.label]];
-        if (startsWith(label, "place/")) {
-            st.places++;
-        } else if (startsWith(label, "poi/")) {
-            if (p.name != EXTRACT_NONE) {
-                st.namedPois++;
-            } else {
-                st.unnamedPois++;
-            }
-        } else {
-            st.otherNamed++;
-        }
-    }
-    // Settlements for the village rule
-    settlements.clear();
-    for (size_t i = 0; i < points.size(); i++) {
-        if (points[i].settlement != EXTRACT_NOT_SETTLEMENT && points[i].name != EXTRACT_NONE) {
-            settlements.push({ static_cast<uint32_t>(i), internName(&text[points[i].name]), points[i].settlement });
-        }
-    }
-    st.settlements = static_cast<uint32_t>(settlements.size());
-    // The region's number style
-    for (const Hs& h : houses) {
-        const HouseNumberStyle kind = houseNumberStyle(&text[h.text]);
-        if (!kind.parsed) {
-            st.textNumbers++;
-        }
-        if (kind.plain) {
-            st.plainNumbers++;
-        }
-        if (kind.slash) {
-            st.slashNumbers++;
-            if (kind.secondSmaller) {
-                st.slashSecondSmaller++;
-            }
-        }
-    }
-    st.plainShare = houses.size() > 0 ? static_cast<double>(st.plainNumbers) / static_cast<double>(houses.size()) : 0.0;
-    st.villageMode = st.plainShare >= config.villageShare && houses.size() > 0;
-    st.slashShare = st.slashNumbers > 0 ? static_cast<double>(st.slashSecondSmaller) / static_cast<double>(st.slashNumbers) : 0.0;
-    st.slashSecond = st.slashShare >= config.slashSecondShare && st.slashNumbers > 0;
-    if (anyFailed() || !makeClusters(mpu)) {
-        return fail("no memory for the street clusters");
-    }
-    st.streetNames = static_cast<uint32_t>(streets.size());
-    st.clusters = static_cast<uint32_t>(clusters.size());
-    if (!matchHouses(config, mpu, st.villageMode, st.slashSecond)) {
-        return errorText[0] != '\0' ? false : fail("no memory for the house matching");
-    }
-    if (!assemble(config)) {
-        return fail("no memory for the index input");
-    }
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------ number helpers
-
-HouseNumberStyle houseNumberStyle(const char* text) {
-    HouseNumberStyle k = {};
-    k.parsed = parseHouseNumber(text, strlen(text), k.number);
-    if (k.parsed) {
-        k.plain = k.number.aux == 0 && k.number.suffix == 0 && k.number.flags == 0;
-        k.slash = (k.number.flags & HOUSE_SLASH) != 0 && k.number.aux != 0;
-        k.secondSmaller = k.slash && k.number.aux < k.number.number;
-    }
-    return k;
-}
-
-int32_t houseVoteNumber(const char* text, bool slashSecond) {
-    const HouseNumberStyle kind = houseNumberStyle(text);
-    if (kind.parsed) {
-        if (kind.slash && slashSecond) {
-            return static_cast<int32_t>(kind.number.aux);
-        }
-        return static_cast<int32_t>(kind.number.number);
-    }
-    int32_t value = 0;
-    int digits = 0;
-    while (text[digits] >= '0' && text[digits] <= '9' && digits < 9) {
-        value = value * 10 + (text[digits] - '0');
-        digits++;
-    }
-    return digits > 0 ? value : -1;
-}
-
-} // namespace maps
diff --git a/Apps/Maps/main/Source/search/SearchRegion.h b/Apps/Maps/main/Source/search/SearchRegion.h
deleted file mode 100644
index 74672b6..0000000
--- a/Apps/Maps/main/Source/search/SearchRegion.h
+++ /dev/null
@@ -1,324 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-#pragma once
-
-#include "../route/GrowArray.h"
-#include "AddressMatch.h"
-#include "QueryParse.h"
-#include "SearchExtract.h"
-#include "SearchIndex.h"
-#include "TextFold.h"
-
-#include <cstddef>
-#include <cstdint>
-
-namespace maps {
-
-/** Metres per z14 unit at a tile row (fractional, e.g. the middle of a region's rows). */
-double metresPerUnitAtTileY(double tileY);
-
-/** An open-addressing table from a 64-bit hash to a caller's index; the caller's callback decides equality. */
-class HashIndex {
-public:
-    static constexpr uint32_t NONE = UINT32_MAX;
-    void clear();
-    void release();
-    /** The value stored under the hash for which eq(value) is true, or NONE. */
-    template <typename Eq>
-    uint32_t find(uint64_t hash, Eq eq) const {
-        if (values.size() == 0) {
-            return NONE;
-        }
-        const size_t mask = values.size() - 1;
-        for (size_t i = static_cast<size_t>(hash) & mask; values[i] != NONE; i = (i + 1) & mask) {
-            if (hashes[i] == hash && eq(values[i])) {
-                return values[i];
-            }
-        }
-        return NONE;
-    }
-    /** Adds a value (the caller has checked it is not there). */
-    void insert(uint64_t hash, uint32_t value);
-    /** A value could not be added (no memory to grow): the index misses it. */
-    bool failed() const { return full || values.failed() || hashes.failed(); }
-
-private:
-    void put(uint64_t hash, uint32_t value);
-    GrowArray<uint32_t> values;
-    GrowArray<uint64_t> hashes;
-    size_t used = 0;
-    bool full = false;
-};
-
-/**
- * The search keys of a name as the study makes them (fold.search_keys and suffix_keys): the folded name (transliterated
- * and original-folded for Greek and Cyrillic), name:latin, name_en when useEn, then the text from each later word of at
- * least 3 characters. Duplicates are left out; the order is fixed. Also the name's sort key. Shared by the in-memory
- * builder and the streaming one, so both make the same keys.
- */
-class KeyMaker {
-public:
-    /** Makes the keys of a name; false when out of memory. */
-    bool make(const char* name, const char* latin, const char* en, bool useEn, Translit profile);
-    /** The sort key (name groups are ordered by it). */
-    const char* sortKey() const { return &pool[0]; }
-    uint32_t count() const { return static_cast<uint32_t>(offsets.size()); }
-    const char* key(uint32_t index) const { return &pool[offsets[index]]; }
-    /** Only the sort key, without the other keys. */
-    static void sortKeyOf(const char* name, Translit profile, char* out, size_t outSize);
-    void release() {
-        pool.release();
-        offsets.release();
-    }
-
-private:
-    static constexpr size_t BUFFER = 2048;
-    bool has(const char* key) const;
-    void add(const char* key);
-    char scratch[5][BUFFER] = {};
-    GrowArray<char> pool;
-    GrowArray<uint32_t> offsets;
-};
-
-struct RegionConfig {
-    /** Transliteration of Greek and Cyrillic names (the study's PROFILE map: Ukrainian for kyiv, Serbian for belgrade, else Russian). */
-    Translit profile = Translit::Russian;
-    /** Metres per z14 unit; 0 takes it from the middle row of the region's tiles. */
-    double metresPerUnit = 0.0;
-    /**
-     * Named lines of class path, track, aerialway, ferry and rail take part in the house matching. The study's counts
-     * leave them out; with them 88.3 % of Bratislava's numbers get the street of OSM's addr:street instead of 87.2 %
-     * (host/search/gt_cpp.py, 12 Nov 2026), and the brief asks for named paths and pedestrian streets.
-     */
-    bool matchPathLines = true;
-    /** For "x/y" numbers of a conscription/street region the vote compares the street number (second part). */
-    bool voteSlashSecond = true;
-    /** The share of plain numbers from which a region is in village mode, and of x/y numbers with a smaller second part for slash_second. */
-    double villageShare = 0.30;
-    double slashSecondShare = 0.80;
-};
-
-struct RegionStats {
-    uint32_t tiles = 0;
-    // What was extracted, deduplicated across tiles (for comparison with the study's counts)
-    uint32_t places = 0;
-    uint32_t namedPois = 0;
-    uint32_t unnamedPois = 0;
-    uint32_t otherNamed = 0;
-    uint32_t junkPoisSkipped = 0;
-    uint32_t streetNames = 0;
-    uint32_t lines = 0;
-    uint32_t clusters = 0;
-    uint32_t refOnlyLines = 0;
-    uint32_t settlements = 0;
-    uint32_t houses = 0;
-    // House number grammar
-    uint32_t plainNumbers = 0;
-    double plainShare = 0;
-    bool villageMode = false;
-    uint32_t slashNumbers = 0;
-    uint32_t slashSecondSmaller = 0;
-    double slashShare = 0;
-    bool slashSecond = false;
-    uint32_t textNumbers = 0;
-    // The path of each house number: street within 50 m, street 50 to 100 m, village only, none
-    uint32_t pathStreet50 = 0;
-    uint32_t pathStreet100 = 0;
-    uint32_t pathVillage = 0;
-    uint32_t pathNone = 0;
-    /** Houses that also went under a settlement while having a street (counted in the street paths above). */
-    uint32_t alsoVillage = 0;
-    uint32_t pseudoStreets = 0;
-    uint32_t droppedAddresses = 0;
-    uint32_t addresses = 0;
-};
-
-/** One house number and where it went, for dumps and checks. */
-struct HouseView {
-    const char* text;
-    int32_t x;
-    int32_t y;
-    /** The matched street name, nullptr for none. */
-    const char* street;
-    AddressTier tier;
-    float streetM;
-    /** The settlement the number also went under, nullptr for none. */
-    const char* village;
-    bool villageStyle;
-};
-
-/**
- * The region-level extraction and matching, host sized (everything in RAM): addTile() for every z14 tile, then
- * buildSearchInput(). The SearchInput points into the builder, which must outlive its use. The device will stream
- * the same steps; this is the reference for them.
- *
- * What it does (M6 study rules, docs/M6-search-study.md):
- *  - points are deduplicated by (label, name, x, y), lines by (name, points), house numbers by (text, x, y);
- *  - street clusters: same-name lines whose vertices are in the same or adjacent 150 m cell (union-find), representative
- *    vertex nearest to the centroid, bounding box;
- *  - house numbers: matched per tile with AddressMatcher, with the lines of the neighbour tiles up to 160 m outside the
- *    tile and the neighbouring houses up to 60 m outside (for the street-run vote; their own results are not used). The
- *    matcher's street ids are cluster ids, so the match is already the cluster nearest to the house;
- *  - slash_second (street number is the second part of "x/y") when at least RegionConfig::slashSecondShare of the
- *    region's "x/y" numbers have a smaller second part (the study's rule); the vote uses that part as the street number;
- *  - village mode when at least RegionConfig::villageShare of all numbers are plain ("245"); then plain numbers also go
- *    under their best settlement (matcher's villages[0]) as an address with ADDRESS_VILLAGE under a street record named
- *    like the place, with a one-point cluster; with a street within 50 m they are under the street too, within 50 to
- *    100 m under it with ADDRESS_LOW;
- *  - keys exactly as the study (search_keys and suffix_keys with TextFold), name_en only for places, water, peaks, parks.
- */
-class SearchRegionBuilder {
-public:
-    SearchRegionBuilder();
-    ~SearchRegionBuilder();
-    SearchRegionBuilder(const SearchRegionBuilder&) = delete;
-    SearchRegionBuilder& operator=(const SearchRegionBuilder&) = delete;
-
-    /** Extracts one tile and merges it. */
-    bool addTile(MvtDecoder& decoder, ByteInput* input, int tileX, int tileY);
-    /** Clusters, matching, keys. Call once, after the last tile. */
-    bool buildSearchInput(const RegionConfig& config);
-
-    const SearchInput& input() const { return searchInput; }
-    const RegionStats& stats() const { return statistics; }
-    const char* error() const { return errorText; }
-
-    size_t houseCount() const { return houses.size(); }
-    HouseView house(size_t index) const;
-
-private:
-    struct Pt {
-        uint32_t label;
-        uint32_t name;
-        uint32_t latin;
-        uint32_t en;
-        int32_t x, y;
-        uint8_t settlement;
-        uint8_t useEn;
-    };
-    struct Ln {
-        uint32_t nameId;
-        uint32_t latin;
-        uint32_t first;
-        uint32_t count;
-        uint32_t cluster;
-        int32_t minX, minY, maxX, maxY;
-        uint8_t pathClass;
-    };
-    struct Hs {
-        uint32_t text;
-        int32_t x, y;
-        uint32_t tile;
-        /** Its index in the extract of the tile that owns it: the order of the tile's houses (the streaming build's too). */
-        uint32_t local;
-        uint8_t inside;
-        uint8_t tier;
-        uint32_t cluster;
-        uint32_t village;
-        float streetM;
-        uint8_t villageStyle;
-    };
-    struct TileRef {
-        int x, y;
-    };
-    struct Cluster {
-        uint32_t street;
-        int32_t repX, repY, minX, minY, maxX, maxY;
-    };
-    struct Street {
-        uint32_t nameId;
-        uint32_t latin;
-        uint32_t en;
-        uint32_t firstCluster;
-        uint32_t clusterCount;
-        uint8_t useEn;
-    };
-    struct Settlement {
-        uint32_t point;
-        uint32_t nameId;
-        uint8_t placeClass;
-    };
-    struct Pseudo {
-        uint32_t street;
-        uint32_t settlement;
-    };
-    struct AddressRec {
-        uint32_t cluster;
-        uint32_t house;
-        uint8_t flags;
-    };
-    struct KeyRef {
-        uint32_t sortKey;
-        uint32_t first;
-        uint32_t count;
-    };
-
-    uint32_t copyText(const char* text);
-    uint32_t internLabel(const char* label);
-    uint32_t internName(const char* name);
-    const char* textAt(uint32_t offset) const { return offset == EXTRACT_NONE ? nullptr : &text[offset]; }
-    bool mergeTile(const ExtractedTile& tile, uint32_t tileIndex);
-    bool makeClusters(double metresPerUnit);
-    bool matchHouses(const RegionConfig& config, double metresPerUnit, bool villageMode, bool slashSecond);
-    bool assemble(const RegionConfig& config);
-    KeyRef makeKeys(const char* name, const char* latin, const char* en, bool useEn, Translit profile);
-    bool anyFailed() const;
-    bool fail(const char* message);
-
-    GrowArray<char> text;
-    HashIndex labelIndex;
-    GrowArray<uint32_t> labelOffsets;
-    HashIndex nameIndex;
-    GrowArray<uint32_t> nameOffsets;
-    HashIndex pointIndex;
-    HashIndex lineIndex;
-    HashIndex houseIndex;
-    HashIndex tileIndex;
-    GrowArray<Pt> points;
-    GrowArray<Ln> lines;
-    GrowArray<int32_t> linePoints;
-    GrowArray<Hs> houses;
-    GrowArray<TileRef> tiles;
-    GrowArray<Cluster> clusters;
-    GrowArray<Street> streets;
-    GrowArray<Settlement> settlements;
-    GrowArray<Pseudo> pseudos;
-    GrowArray<AddressRec> addressRecs;
-    GrowArray<uint32_t> settlementPseudo;
-    GrowArray<uint32_t> nameStreet;
-    // Keys
-    GrowArray<char> keyPool;
-    GrowArray<uint32_t> keyOffsets;
-    GrowArray<KeyRef> pointKeys;
-    GrowArray<KeyRef> streetKeys;
-    HashIndex keyShare;
-    // The writer's input
-    GrowArray<SearchPointInput> pointInputs;
-    GrowArray<SearchStreetInput> streetInputs;
-    GrowArray<SearchClusterInput> clusterInputs;
-    GrowArray<SearchAddressInput> addressInputs;
-    GrowArray<const char*> keyPointers;
-    GrowArray<const char*> categoryNames;
-    GrowArray<const char*> categoryKeys;
-    SearchInput searchInput = {};
-    RegionStats statistics;
-    ExtractedTile tileBuffer;
-    TileExtractor extractor;
-    AddressMatcher matcher;
-    char errorText[160] = {};
-    KeyMaker keyMaker;
-    char categoryScratch[2048] = {};
-};
-
-/** The house number's grammar as the region statistics count it (both builders use it, so their files match). */
-struct HouseNumberStyle {
-    bool parsed;
-    bool plain;
-    bool slash;
-    bool secondSmaller;
-    HouseNumber number;
-};
-HouseNumberStyle houseNumberStyle(const char* text);
-/** The street number a house votes with: the second part of "x/y" when slashSecond, else the first; -1 for none. */
-int32_t houseVoteNumber(const char* text, bool slashSecond);
-
-} // namespace maps
diff --git a/Apps/Maps/main/Source/search/SearchStream.cpp b/Apps/Maps/main/Source/search/SearchStream.cpp
index f3416a1..dcebb84 100644
--- a/Apps/Maps/main/Source/search/SearchStream.cpp
+++ b/Apps/Maps/main/Source/search/SearchStream.cpp
@@ -1409,7 +1409,9 @@ struct SearchStreamBuilder::Impl {
         }
         // Union-find over the lines: the same cell, or touching cells (8 neighbours), of the same name join
         GrowArray<uint32_t>& parent = lineCluster;
-        parent.resize(lineTotal);
+        if (!parent.resize(lineTotal)) {
+            return fail("no memory for the streets");
+        }
         for (uint32_t i = 0; i < lineTotal; i++) {
             parent[i] = i;
         }
@@ -1477,12 +1479,16 @@ struct SearchStreamBuilder::Impl {
         current.release();
         // Components: one per root, numbered in line order
         GrowArray<uint32_t> compOfRoot;
-        compOfRoot.resize(lineTotal);
+        if (!compOfRoot.resize(lineTotal)) {
+            return fail("no memory for the streets");
+        }
         for (uint32_t i = 0; i < lineTotal; i++) {
             compOfRoot[i] = NONE;
         }
         GrowArray<uint32_t> compOfLine;
-        compOfLine.resize(lineTotal);
+        if (!compOfLine.resize(lineTotal)) {
+            return fail("no memory for the streets");
+        }
         for (uint32_t i = 0; i < lineTotal; i++) {
             const uint32_t root = find(i);
             if (compOfRoot[root] == NONE) {
@@ -1606,7 +1612,9 @@ struct SearchStreamBuilder::Impl {
             }
         }
         // Lines point at the sorted clusters (the order array becomes the inverse map)
-        compOfRoot.resize(comps.size());
+        if (!compOfRoot.resize(comps.size())) {
+            return fail("no memory for the streets");
+        }
         for (uint32_t k = 0; k < order.size(); k++) {
             compOfRoot[order[k]] = k;
         }
@@ -2872,7 +2880,13 @@ bool SearchStreamBuilder::build(ScratchFiles& files, const char* scratchDir, con
     b.regionMpu = b.config.metresPerUnit > 0 ? b.config.metresPerUnit : metresPerUnitAtTileY((minY + maxY + 1) / 2.0);
     b.progress.total = 2 * tileCount + 7;
     bool ok = !b.tiles.failed() && !b.tileIndex.failed();
-    ok = ok && b.readTiles() && b.dedupPoints() && b.filterHouses() && b.makeClusters() && b.matchHouses() && b.makeAddresses();
+    // The step, for the memory log of the caller's hook
+    auto at = [&b](uint8_t phase) {
+        b.progress.phase = phase;
+        return true;
+    };
+    ok = ok && b.readTiles() && at(1) && b.dedupPoints() && at(2) && b.filterHouses() && at(3) && b.makeClusters() && at(4) && b.matchHouses() &&
+        at(5) && b.makeAddresses();
     uint32_t pts = 4;
     if (ok) {
         const int64_t span = std::max<int64_t>(static_cast<int64_t>(b.maxX) - b.minX, static_cast<int64_t>(b.maxY) - b.minY);
@@ -2881,7 +2895,7 @@ bool SearchStreamBuilder::build(ScratchFiles& files, const char* scratchDir, con
             b.minX = b.minY = 0;
         }
     }
-    ok = ok && b.writeAddressRecords(pts) && b.pointGroups() && b.writeGroups(pts) && b.writeKeys() &&
+    ok = ok && at(6) && b.writeAddressRecords(pts) && at(7) && b.pointGroups() && at(8) && b.writeGroups(pts) && at(9) && b.writeKeys() && at(10) &&
         b.writeFile(outPath, temporaryPath, pts);
     b.noteTables();
     b.removeScratch();
diff --git a/Apps/Maps/main/Source/search/SearchStream.h b/Apps/Maps/main/Source/search/SearchStream.h
index 0d9f19c..04d3762 100644
--- a/Apps/Maps/main/Source/search/SearchStream.h
+++ b/Apps/Maps/main/Source/search/SearchStream.h
@@ -10,7 +10,7 @@
 #include "ScratchFiles.h"
 #include "SearchExtract.h"
 #include "SearchIndex.h"
-#include "SearchRegion.h"
+#include "SearchCommon.h"
 
 #include <cstddef>
 #include <cstdint>
@@ -37,6 +37,9 @@ class StreamTileSource {
 struct StreamProgress {
     uint32_t done;
     uint32_t total;
+    /** The step the build is in: 0 tiles, 1 points, 2 houses, 3 clusters, 4 matching, 5 addresses, 6 address records, 7 groups,
+     *  8 group records, 9 keys, 10 file. */
+    uint8_t phase;
 };
 
 struct StreamBuildOptions {
diff --git a/Apps/Maps/main/Source/search/TextFold.cpp b/Apps/Maps/main/Source/search/TextFold.cpp
index b1b8370..c047b57 100644
--- a/Apps/Maps/main/Source/search/TextFold.cpp
+++ b/Apps/Maps/main/Source/search/TextFold.cpp
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // The study's text folding (host/search/fold.py) for search keys and queries. The character tables are made from
-// fold.py by tools/make_fold_table.py (FoldTable.h).
+// fold.py by host/search/make_fold_table.py (FoldTable.h).
 #include "TextFold.h"
 
 #include "FoldTable.h"
diff --git a/Apps/Maps/main/Source/tiles/BrowsedMove.cpp b/Apps/Maps/main/Source/tiles/BrowsedMove.cpp
index e748686..77f4c3d 100644
--- a/Apps/Maps/main/Source/tiles/BrowsedMove.cpp
+++ b/Apps/Maps/main/Source/tiles/BrowsedMove.cpp
@@ -63,7 +63,9 @@ BrowsedMove moveBrowsedFiles(const char* root, const char* region, const TileKey
     if (tileVersion[0] == '\0' && browsedVersion != nullptr) {
         snprintf(tileVersion, sizeof(tileVersion), "%s", browsedVersion);
     }
-    if (version != nullptr && version[0] != '\0' && tileVersion[0] != '\0' && strcmp(version, tileVersion) != 0) {
+    // The tile's version is at most PREPARED_VERSION_LENGTH characters, the region's can be longer
+    if (version != nullptr && version[0] != '\0' && tileVersion[0] != '\0' &&
+        strncmp(version, tileVersion, PREPARED_VERSION_LENGTH) != 0) {
         return BrowsedMove::Stale;
     }
     char folder[PATH_MAX_LENGTH];
diff --git a/Apps/Maps/main/Source/tiles/RegionMeta.cpp b/Apps/Maps/main/Source/tiles/RegionMeta.cpp
index 8c4fca3..e699f56 100644
--- a/Apps/Maps/main/Source/tiles/RegionMeta.cpp
+++ b/Apps/Maps/main/Source/tiles/RegionMeta.cpp
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "RegionMeta.h"
 
+#include "../platform/SafeFile.h"
+
 #include <cinttypes>
 #include <cstdio>
 #include <cstring>
@@ -193,16 +195,17 @@ bool writeRegionMeta(const char* path, const RegionMeta& meta) {
     }
     const size_t length = strlen(text);
     const bool ok = fwrite(text, 1, length, file) == length;
-    fclose(file);
-    remove(path);
-    if (!ok || rename(temporary, path) != 0) {
+    // The old file goes only once the new one is whole (a failed write must not cost the old one)
+    if (fclose(file) != 0 || !ok) {
         remove(temporary);
         return false;
     }
-    return true;
+    // A failed replace keeps the temporary file: the old one may be gone already, and recoverFile() needs it
+    return replaceFile(temporary, path);
 }
 
 bool readRegionMeta(const char* path, RegionMeta& meta) {
+    recoverFile(path);
     FILE* file = fopen(path, "r");
     if (file == nullptr) {
         return false;
diff --git a/Apps/Maps/main/Source/tiles/TileStore.cpp b/Apps/Maps/main/Source/tiles/TileStore.cpp
index e9e9bb4..6c342b8 100644
--- a/Apps/Maps/main/Source/tiles/TileStore.cpp
+++ b/Apps/Maps/main/Source/tiles/TileStore.cpp
@@ -37,7 +37,7 @@ void TileStore::setRoot(const char* path) {
 }
 
 bool TileStore::addRegion(const char* name) {
-    if (count >= MAX_REGIONS || !isValidRegionName(name)) {
+    if (!isValidRegionName(name)) {
         return false;
     }
     for (int i = 0; i < count; i++) {
@@ -45,6 +45,11 @@ bool TileStore::addRegion(const char* name) {
             return true;
         }
     }
+    if (count >= MAX_REGIONS) {
+        // Not silent: its tiles would otherwise just never show
+        logError("Region %s is left out: the app handles at most %d regions", name, MAX_REGIONS);
+        return false;
+    }
     snprintf(regions[count], sizeof(regions[count]), "%s", name);
     versions[count][0] = '\0';
     bounds[count] = {};
diff --git a/Apps/Maps/main/Source/ui/BackgroundWork.cpp b/Apps/Maps/main/Source/ui/BackgroundWork.cpp
index 5a473a4..f1a6fa6 100644
--- a/Apps/Maps/main/Source/ui/BackgroundWork.cpp
+++ b/Apps/Maps/main/Source/ui/BackgroundWork.cpp
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "BackgroundWork.h"
 
+#include "Metrics.h"
+
 #include <algorithm>
 #include <cmath>
 #include <cstdio>
@@ -10,7 +12,7 @@ namespace maps {
 
 namespace {
 
-constexpr int PADDING = 8;
+using metrics::PADDING;
 
 const char* workName(WorkKind kind) {
     switch (kind) {
@@ -102,7 +104,9 @@ void drawWorkDot(Canvas& canvas, int x, int y, uint16_t color) {
 }
 
 Rect workDotTarget(int x, int y) {
-    return { x - 12, y - 12, 24, 24 };
+    // A finger wide on boards without a typing keyboard
+    const int size = metrics::touchTargets() ? metrics::TOUCH_BUTTON_HEIGHT : 24;
+    return { x - size / 2, y - size / 2, size, size };
 }
 
 void WorkCard::open() {
@@ -123,17 +127,17 @@ void WorkCard::set(const BackgroundWork& work) {
 }
 
 void WorkCard::layout(int width, int height, Font& font) {
-    const int cardWidth = std::min(width - 16, 300);
     const int line = font.lineHeight();
-    const int buttonHeight = line + 12;
+    const int cardWidth = metrics::cardWidth(width, height, 16, 300, line);
+    const int buttonHeight = metrics::buttonHeight(line, 12);
     const int cardHeight = PADDING + (1 + lineCount) * line + PADDING + buttonHeight + PADDING;
     frame = { (width - cardWidth) / 2, (height - cardHeight) / 2, cardWidth, cardHeight };
     closeBtn = { frame.x + PADDING, frame.y + cardHeight - PADDING - buttonHeight, cardWidth - 2 * PADDING, buttonHeight };
 }
 
 void WorkCard::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
-    canvas.fillRect(0, 0, canvas.width, canvas.height, theme.scrim, 110);
-    canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, 8, theme.panel);
+    canvas.fillRect(0, 0, canvas.width, canvas.height, theme.scrim, metrics::SCRIM_ALPHA);
+    canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, metrics::PANEL_RADIUS, theme.panel, theme.panelOpacity);
     const int left = frame.x + PADDING;
     const int textWidth = frame.width - 2 * PADDING;
     int y = frame.y + PADDING;
diff --git a/Apps/Maps/main/Source/ui/BackgroundWork.h b/Apps/Maps/main/Source/ui/BackgroundWork.h
index 1f7feee..5cea738 100644
--- a/Apps/Maps/main/Source/ui/BackgroundWork.h
+++ b/Apps/Maps/main/Source/ui/BackgroundWork.h
@@ -77,6 +77,8 @@ class WorkCard {
     void draw(Canvas& canvas, Font& font, const UiTheme& theme);
     bool hitClose(int x, int y) const;
     Rect closeButton() const;
+    /** For tests: the card. */
+    const Rect& bounds() const { return frame; }
 
 private:
     bool visible = false;
diff --git a/Apps/Maps/main/Source/ui/Controls.cpp b/Apps/Maps/main/Source/ui/Controls.cpp
index 0e632ab..05f83ed 100644
--- a/Apps/Maps/main/Source/ui/Controls.cpp
+++ b/Apps/Maps/main/Source/ui/Controls.cpp
@@ -1,15 +1,33 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "Controls.h"
 
+#include "Metrics.h"
+
 #include <algorithm>
 
 namespace maps {
 
+int Controls::sizeFor(int width, int height) {
+    const int shortSide = std::min(width, height);
+    int result = std::clamp(shortSide / 10, SIZE, MAX_SIZE);
+    // A low screen: the zoom pair, the position button and the menu pair must fit one above the other
+    if (height < 200) {
+        result = std::max(20, std::min(result, height / 6));
+    } else if (metrics::touchTargets()) {
+        // A finger-sized button on touch boards
+        result = std::max(result, metrics::TOUCH_BUTTON_HEIGHT);
+    }
+    return result;
+}
+
 void Controls::layout(int width, int height, int scaleBarTop, int top) {
     // The zoom pair sits on the right edge around the middle, the position button above the scale bar
+    size = sizeFor(width, height);
+    const int SIZE = size;
     rects[static_cast<int>(Control::Menu)] = { EDGE, top + EDGE, SIZE, SIZE };
     rects[static_cast<int>(Control::ZoomIn)] = { width - EDGE - SIZE, height / 2 - SIZE - 3, SIZE, SIZE };
     rects[static_cast<int>(Control::ZoomOut)] = { width - EDGE - SIZE, height / 2 + 3, SIZE, SIZE };
+    rects[static_cast<int>(Control::Search)] = { EDGE, top + EDGE + SIZE + EDGE, SIZE, SIZE };
     const int positionTop = std::max(height / 2 + SIZE + 12, scaleBarTop - EDGE - SIZE);
     rects[static_cast<int>(Control::Position)] = { width - EDGE - SIZE, positionTop, SIZE, SIZE };
 }
@@ -51,6 +69,8 @@ char Controls::keyOf(Control control) {
             return 'O';
         case Control::Position:
             return 'G';
+        case Control::Search:
+            return '/';
         default:
             return 0;
     }
@@ -70,6 +90,8 @@ Control Controls::controlForKey(uint32_t key) {
         case 'g':
         case 'G':
             return Control::Position;
+        case '/':
+            return Control::Search;
         default:
             return Control::None;
     }
@@ -84,37 +106,44 @@ void Controls::moveFocus(int steps) {
 void Controls::drawIcon(Canvas& canvas, Control control, const Rect& r, uint16_t color, PositionButton position, const UiTheme& theme) {
     const float cx = static_cast<float>(r.x) + r.width / 2.0f;
     const float cy = static_cast<float>(r.y) + r.height / 2.0f;
+    // The icons are drawn for 32 px buttons and scaled to the real size
+    const float k = static_cast<float>(r.width) / 32.0f;
     switch (control) {
         case Control::Menu:
             for (int i = -1; i <= 1; i++) {
-                canvas.line(cx - 7.0f, cy + i * 5.0f, cx + 7.0f, cy + i * 5.0f, 2.2f, color);
+                canvas.line(cx - 7.0f * k, cy + i * 5.0f * k, cx + 7.0f * k, cy + i * 5.0f * k, 2.2f * k, color);
             }
             break;
         case Control::ZoomIn:
-            canvas.line(cx - 7.0f, cy, cx + 7.0f, cy, 2.4f, color);
-            canvas.line(cx, cy - 7.0f, cx, cy + 7.0f, 2.4f, color);
+            canvas.line(cx - 7.0f * k, cy, cx + 7.0f * k, cy, 2.4f * k, color);
+            canvas.line(cx, cy - 7.0f * k, cx, cy + 7.0f * k, 2.4f * k, color);
             break;
         case Control::ZoomOut:
-            canvas.line(cx - 7.0f, cy, cx + 7.0f, cy, 2.4f, color);
+            canvas.line(cx - 7.0f * k, cy, cx + 7.0f * k, cy, 2.4f * k, color);
             break;
         case Control::Position:
-            canvas.ring(cx, cy, 6.0f, 2.0f, color);
-            canvas.line(cx, cy - 11.0f, cx, cy - 7.0f, 2.0f, color);
-            canvas.line(cx, cy + 7.0f, cx, cy + 11.0f, 2.0f, color);
-            canvas.line(cx - 11.0f, cy, cx - 7.0f, cy, 2.0f, color);
-            canvas.line(cx + 7.0f, cy, cx + 11.0f, cy, 2.0f, color);
+            canvas.ring(cx, cy, 6.0f * k, 2.0f * k, color);
+            canvas.line(cx, cy - 11.0f * k, cx, cy - 7.0f * k, 2.0f * k, color);
+            canvas.line(cx, cy + 7.0f * k, cx, cy + 11.0f * k, 2.0f * k, color);
+            canvas.line(cx - 11.0f * k, cy, cx - 7.0f * k, cy, 2.0f * k, color);
+            canvas.line(cx + 7.0f * k, cy, cx + 11.0f * k, cy, 2.0f * k, color);
             if (position == PositionButton::Following) {
-                canvas.fillCircle(cx, cy, 3.0f, color);
+                canvas.fillCircle(cx, cy, 3.0f * k, color);
             } else if (position == PositionButton::FollowingHeading) {
                 // A pointer to the top: the direction of travel is up
-                canvas.line(cx, cy - 4.0f, cx - 3.0f, cy + 3.0f, 2.2f, color);
-                canvas.line(cx, cy - 4.0f, cx + 3.0f, cy + 3.0f, 2.2f, color);
+                canvas.line(cx, cy - 4.0f * k, cx - 3.0f * k, cy + 3.0f * k, 2.2f * k, color);
+                canvas.line(cx, cy - 4.0f * k, cx + 3.0f * k, cy + 3.0f * k, 2.2f * k, color);
             } else if (position == PositionButton::Unavailable) {
                 // Crossed out, with a gap in the panel colour so the slash reads on the icon
-                canvas.line(cx - 10.0f, cy + 10.0f, cx + 10.0f, cy - 10.0f, 4.5f, theme.panel);
-                canvas.line(cx - 10.0f, cy + 10.0f, cx + 10.0f, cy - 10.0f, 2.0f, color);
+                canvas.line(cx - 10.0f * k, cy + 10.0f * k, cx + 10.0f * k, cy - 10.0f * k, 4.5f * k, theme.panel);
+                canvas.line(cx - 10.0f * k, cy + 10.0f * k, cx + 10.0f * k, cy - 10.0f * k, 2.0f * k, color);
             }
             break;
+        case Control::Search:
+            // A magnifier: a lens ring and a handle towards the bottom right
+            canvas.ring(cx - 2.0f * k, cy - 2.0f * k, 5.5f * k, 2.2f * k, color);
+            canvas.line(cx + 2.0f * k, cy + 2.0f * k, cx + 8.0f * k, cy + 8.0f * k, 2.6f * k, color);
+            break;
         default:
             break;
     }
diff --git a/Apps/Maps/main/Source/ui/Controls.h b/Apps/Maps/main/Source/ui/Controls.h
index 80bd2ec..ff869c9 100644
--- a/Apps/Maps/main/Source/ui/Controls.h
+++ b/Apps/Maps/main/Source/ui/Controls.h
@@ -14,6 +14,8 @@ enum class Control : uint8_t {
     ZoomIn,
     ZoomOut,
     Position,
+    /** Opens the search, like the key "/"; sits under the menu button. Last in the enum so the focus order of the others stays. */
+    Search,
     Count,
     None = Count
 };
@@ -35,15 +37,19 @@ struct InputKinds {
 };
 
 /**
- * The hidden control overlay, laid out for the screen: menu top left, zoom in and out in the middle of the
+ * The hidden control overlay, laid out for the screen: menu top left with search under it, zoom in and out in the middle of the
  * right edge, position bottom right above the scale bar. Buttons are about 32 px, at least 6 px from the edge,
  * semi-transparent, never over the screen centre. With a keyboard each button shows its key. On boards with
  * only buttons (no touch, no pointer) one control has the focus, which arrows move and Enter presses.
  */
 class Controls {
 public:
+    /** The size on a 240 px screen and the smallest bigger screens get; bigger screens grow to at most MAX_SIZE. */
     static constexpr int SIZE = 32;
+    static constexpr int MAX_SIZE = 48;
     static constexpr int EDGE = 6;
+    /** The button size for a screen: SIZE up to 320 px, 1/10 of the short side up to MAX_SIZE, less on a low screen. */
+    static int sizeFor(int width, int height);
 
     /** top: the height of a bar along the top edge (navigation), the menu button goes below it. */
     void layout(int width, int height, int scaleBarTop, int top = 0);
@@ -76,6 +82,7 @@ class Controls {
 private:
     void drawIcon(Canvas& canvas, Control control, const Rect& rect, uint16_t color, PositionButton position, const UiTheme& theme);
 
+    int size = SIZE;
     Rect rects[static_cast<int>(Control::Count)] {};
     InputKinds inputs { true, true, false };
     bool visible = false;
diff --git a/Apps/Maps/main/Source/ui/DownloadFrame.cpp b/Apps/Maps/main/Source/ui/DownloadFrame.cpp
index b3a942b..8c6135b 100644
--- a/Apps/Maps/main/Source/ui/DownloadFrame.cpp
+++ b/Apps/Maps/main/Source/ui/DownloadFrame.cpp
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "DownloadFrame.h"
 
+#include "Metrics.h"
+
 #include <algorithm>
 #include <cstdio>
 
@@ -8,16 +10,19 @@ namespace maps {
 
 namespace {
 
+/** The Download button on the 16 px font; wider with a bigger one. */
 constexpr int BUTTON_WIDTH = 92;
 
 } // namespace
 
 DownloadLayout downloadLayout(int width, int height, int lineHeight) {
     DownloadLayout layout {};
-    const int barHeight = 2 * lineHeight + 10;
+    // A button a finger can hit on boards without a typing keyboard
+    const int barHeight = metrics::touchTargets() ? std::max(2 * lineHeight + 10, metrics::TOUCH_BUTTON_HEIGHT + 10) : 2 * lineHeight + 10;
+    const int buttonWidth = std::min(std::max(BUTTON_WIDTH, lineHeight * 23 / 4), width / 2);
     layout.bar = { 0, height - barHeight, width, barHeight };
-    layout.button = { width - BUTTON_WIDTH - 5, layout.bar.y + 5, BUTTON_WIDTH, barHeight - 10 };
-    layout.mark = { 0, layout.bar.y, 18, barHeight };
+    layout.button = { width - buttonWidth - 5, layout.bar.y + 5, buttonWidth, barHeight - 10 };
+    layout.mark = { 0, layout.bar.y, std::max(18, lineHeight + 2), barHeight };
     const int margin = DownloadLayout::MARGIN;
     layout.frame = { margin, margin, width - 2 * margin, layout.bar.y - 2 * margin };
     layout.back = { margin + 4, margin + 4, 36, 36 };
@@ -68,18 +73,17 @@ void drawDownloadScreen(Canvas& canvas, Font& font, const UiTheme& theme, const
     // Outside the frame the map stays dimmed, the frame itself never moves
     const Rect& f = layout.frame;
     const Rect& bar = layout.bar;
-    canvas.fillRect(0, 0, canvas.width, f.y, theme.scrim, 110);
-    canvas.fillRect(0, f.y + f.height, canvas.width, bar.y - f.y - f.height, theme.scrim, 110);
-    canvas.fillRect(0, f.y, f.x, f.height, theme.scrim, 110);
-    canvas.fillRect(f.x + f.width, f.y, canvas.width - f.x - f.width, f.height, theme.scrim, 110);
+    canvas.fillRect(0, 0, canvas.width, f.y, theme.scrim, metrics::SCRIM_ALPHA);
+    canvas.fillRect(0, f.y + f.height, canvas.width, bar.y - f.y - f.height, theme.scrim, metrics::SCRIM_ALPHA);
+    canvas.fillRect(0, f.y, f.x, f.height, theme.scrim, metrics::SCRIM_ALPHA);
+    canvas.fillRect(f.x + f.width, f.y, canvas.width - f.x - f.width, f.height, theme.scrim, metrics::SCRIM_ALPHA);
     canvas.frameRect(f.x - 2, f.y - 2, f.width + 4, f.height + 4, theme.accent, 2);
     // Back to the map: a round button with the lists' < sign
     const Rect& back = layout.back;
     canvas.fillRoundRect(back.x, back.y, back.width, back.height, back.width / 2, theme.panel, theme.panelOpacity);
     const auto backX = static_cast<float>(back.x + back.width / 2);
     const auto backY = static_cast<float>(back.y + back.height / 2);
-    canvas.line(backX + 3.0f, backY - 7.0f, backX - 4.0f, backY, 2.5f, theme.text);
-    canvas.line(backX - 4.0f, backY, backX + 3.0f, backY + 7.0f, 2.5f, theme.text);
+    metrics::drawBackChevron(canvas, backX, backY, theme.text, 7.0f, 2.5f);
 
     char first[48];
     char second[48];
diff --git a/Apps/Maps/main/Source/ui/DownloadProgress.cpp b/Apps/Maps/main/Source/ui/DownloadProgress.cpp
index 010f7bd..6bf65d9 100644
--- a/Apps/Maps/main/Source/ui/DownloadProgress.cpp
+++ b/Apps/Maps/main/Source/ui/DownloadProgress.cpp
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "DownloadProgress.h"
 
+#include "Metrics.h"
+
 #include <algorithm>
 #include <cstdio>
 #include <cstring>
@@ -9,7 +11,7 @@ namespace maps {
 
 namespace {
 
-constexpr int PADDING = 8;
+using metrics::PADDING;
 constexpr int BUTTON_COUNT = 3;
 
 int characterLength(unsigned char leading) {
@@ -182,10 +184,12 @@ void DownloadCard::set(const char* titleText, const char* const* detailLines, in
 }
 
 void DownloadCard::layout(int width, int height, Font& font) {
-    const int cardWidth = std::min(width - 16, 300);
     const int line = font.lineHeight();
-    const int buttonHeight = line + 12;
-    const int cardHeight = PADDING + (1 + lineCount) * line + PADDING + buttonHeight + PADDING;
+    const int cardWidth = metrics::cardWidth(width, height, 16, 300, line);
+    const int buttonHeight = metrics::buttonHeight(line, 12);
+    // With a keyboard one more muted line lists the keys
+    const int hintHeight = metrics::hasKeyboard() ? line : 0;
+    const int cardHeight = PADDING + (1 + lineCount) * line + hintHeight + PADDING + buttonHeight + PADDING;
     frame = { (width - cardWidth) / 2, (height - cardHeight) / 2, cardWidth, cardHeight };
     const int buttonWidth = (cardWidth - (BUTTON_COUNT + 1) * PADDING) / BUTTON_COUNT;
     const int buttonY = frame.y + cardHeight - PADDING - buttonHeight;
@@ -195,8 +199,8 @@ void DownloadCard::layout(int width, int height, Font& font) {
 }
 
 void DownloadCard::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
-    canvas.fillRect(0, 0, canvas.width, canvas.height, theme.scrim, 110);
-    canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, 8, theme.panel);
+    canvas.fillRect(0, 0, canvas.width, canvas.height, theme.scrim, metrics::SCRIM_ALPHA);
+    canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, metrics::PANEL_RADIUS, theme.panel, theme.panelOpacity);
     const int left = frame.x + PADDING;
     const int textWidth = frame.width - 2 * PADDING;
     int y = frame.y + PADDING;
@@ -206,6 +210,9 @@ void DownloadCard::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
         drawClippedText(canvas, font, left, y, lines[i], textWidth, theme.muted);
         y += font.lineHeight();
     }
+    if (metrics::hasKeyboard()) {
+        drawClippedText(canvas, font, left, y, closeOnly ? "Enter or Esc: close" : "A/D: choose  Enter: press", textWidth, theme.muted);
+    }
     if (!closeOnly) {
         drawButton(canvas, font, theme, buttons[0], paused ? "Resume" : "Pause", focus == 0);
         drawButton(canvas, font, theme, buttons[1], "Cancel", focus == 1, true);
diff --git a/Apps/Maps/main/Source/ui/DownloadProgress.h b/Apps/Maps/main/Source/ui/DownloadProgress.h
index d4f8950..b927b31 100644
--- a/Apps/Maps/main/Source/ui/DownloadProgress.h
+++ b/Apps/Maps/main/Source/ui/DownloadProgress.h
@@ -68,6 +68,9 @@ class DownloadCard {
     Button handleKey(uint32_t key);
     /** A button, Close for a tap outside the card, None inside it. */
     Button handleTap(int x, int y);
+    /** For tests: the card and its buttons (Pause or Resume, Cancel, Close). */
+    const Rect& bounds() const { return frame; }
+    const Rect& buttonRect(int index) const { return buttons[index]; }
 
 private:
     Button buttonAt(int index) const;
diff --git a/Apps/Maps/main/Source/ui/MapOverlay.cpp b/Apps/Maps/main/Source/ui/MapOverlay.cpp
index 9b8aa01..ccb842a 100644
--- a/Apps/Maps/main/Source/ui/MapOverlay.cpp
+++ b/Apps/Maps/main/Source/ui/MapOverlay.cpp
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "MapOverlay.h"
 
+#include "Metrics.h"
+
 #include "../render/Raster.h"
 
 #include <algorithm>
@@ -52,22 +54,28 @@ void MapOverlay::drawAttribution(Canvas& canvas, const Palette& palette, int& bo
 }
 
 void MapOverlay::drawAttributionMark(Canvas& canvas, const Palette& palette) {
-    const int y = canvas.height - bottomInset - MARK_SIZE;
-    canvas.fillRect(0, y, MARK_SIZE, MARK_SIZE, palette.halo, 190);
+    const int size = markSize();
+    const int y = canvas.height - bottomInset - size;
+    canvas.fillRect(0, y, size, size, palette.halo, 190);
     const int markWidth = normal->textWidth(ATTRIBUTION_MARK);
-    normal->drawText(canvas, (MARK_SIZE - markWidth) / 2, y + (MARK_SIZE - normal->lineHeight()) / 2, ATTRIBUTION_MARK, palette.text);
+    normal->drawText(canvas, (size - markWidth) / 2, y + (size - normal->lineHeight()) / 2, ATTRIBUTION_MARK, palette.text);
 }
 
 bool MapOverlay::hitsAttributionMark(const Canvas& canvas, int x, int y) const {
-    return x < MARK_SIZE + 12 && y > canvas.height - bottomInset - MARK_SIZE - 12 && y < canvas.height - bottomInset + 4;
+    return x < markSize() + 12 && y > canvas.height - bottomInset - markSize() - 12 && y < canvas.height - bottomInset + 4;
 }
 
 int MapOverlay::scaleBarTop(const Canvas& canvas) const {
     return canvas.height - bottomInset - normal->lineHeight() - 8;
 }
 
-void MapOverlay::drawScaleBar(Canvas& canvas, double metresPerPixel, const Palette& palette) {
-    constexpr int maxBarPixels = 70;
+int MapOverlay::markSize() const {
+    return std::max(MARK_SIZE, normal->lineHeight() + 2);
+}
+
+Rect MapOverlay::drawScaleBar(Canvas& canvas, double metresPerPixel, const Palette& palette) {
+    // 70 px with the 16 px font, longer with a bigger one
+    const int maxBarPixels = 70 * std::max(16, normal->lineHeight()) / 16;
     const double maxMetres = metresPerPixel * maxBarPixels;
     double niceMetres = 1.0;
     while (niceMetres * 10.0 <= maxMetres) {
@@ -97,6 +105,7 @@ void MapOverlay::drawScaleBar(Canvas& canvas, double metresPerPixel, const Palet
     canvas.fillRect(barX, barY, barPixels, 2, palette.text);
     canvas.fillRect(barX, barY - 3, 1, 5, palette.text);
     canvas.fillRect(barX + barPixels - 1, barY - 3, 1, 5, palette.text);
+    return { boxX, boxY, boxWidth, height + 7 };
 }
 
 Rect MapOverlay::drawPill(Canvas& canvas, const char* text, const Palette& palette) {
@@ -111,8 +120,8 @@ Rect MapOverlay::drawPill(Canvas& canvas, const char* text, const Palette& palet
     return { x, 2, width, height };
 }
 
-void MapOverlay::drawToast(Canvas& canvas, const char* text, const UiTheme& theme) {
-    constexpr int padding = 8;
+Rect MapOverlay::drawToast(Canvas& canvas, const char* text, const UiTheme& theme) {
+    constexpr int padding = metrics::PADDING;
     char lines[2][80];
     const int maxWidth = canvas.width - 4 * padding;
     const int count = wrapText(*normal, text, maxWidth, &lines[0][0], sizeof(lines[0]), 2);
@@ -124,12 +133,13 @@ void MapOverlay::drawToast(Canvas& canvas, const char* text, const UiTheme& them
     const int boxWidth = width + 2 * padding;
     const int boxHeight = count * lineHeight + padding;
     const int x = (canvas.width - boxWidth) / 2;
-    // Above the scale bar and the buttons along the bottom
-    const int y = canvas.height - bottomInset - boxHeight - lineHeight - 50;
+    // Above the scale bar and the buttons along the bottom, but not off the top of a low screen
+    const int y = std::max(0, canvas.height - bottomInset - boxHeight - lineHeight - 50);
     canvas.fillRoundRect(x, y, boxWidth, boxHeight, 6, theme.text, 230);
     for (int i = 0; i < count; i++) {
         normal->drawText(canvas, x + padding, y + padding / 2 + i * lineHeight, lines[i], theme.panel);
     }
+    return { x, y, boxWidth, boxHeight };
 }
 
 void MapOverlay::drawAccuracyCircle(Canvas& canvas, int x, int y, float radius, const Palette& palette) {
diff --git a/Apps/Maps/main/Source/ui/MapOverlay.h b/Apps/Maps/main/Source/ui/MapOverlay.h
index 77d81b0..0c5a60f 100644
--- a/Apps/Maps/main/Source/ui/MapOverlay.h
+++ b/Apps/Maps/main/Source/ui/MapOverlay.h
@@ -31,14 +31,16 @@ class MapOverlay {
     bool hitsAttributionMark(const Canvas& canvas, int x, int y) const;
     /** The top of the scale bar box, buttons above it keep clear of it. */
     int scaleBarTop(const Canvas& canvas) const;
-    void drawScaleBar(Canvas& canvas, double metresPerPixel, const Palette& palette);
+    /** Returns its box. */
+    Rect drawScaleBar(Canvas& canvas, double metresPerPixel, const Palette& palette);
     /**
      * A small rounded message at the top of the screen, for progress. Text too wide for the screen uses the small font
      * and is cut. Returns where the pill is, so a tap on it can open the details.
      */
     Rect drawPill(Canvas& canvas, const char* text, const Palette& palette);
     /** A short message of up to two lines above the bottom edge. */
-    void drawToast(Canvas& canvas, const char* text, const UiTheme& theme);
+    /** Returns its box. */
+    Rect drawToast(Canvas& canvas, const char* text, const UiTheme& theme);
     void drawMarker(Canvas& canvas, int x, int y, bool hasCourse, float courseDegrees, const Palette& palette);
     /** A translucent disc with a thin rim, how far off the position may be. */
     void drawAccuracyCircle(Canvas& canvas, int x, int y, float radius, const Palette& palette);
@@ -49,6 +51,8 @@ class MapOverlay {
     void drawApproximateMarker(Canvas& canvas, int x, int y, float accuracyMetres, const Palette& palette);
 
     static constexpr int MARK_SIZE = 18;
+    /** The � mark box: MARK_SIZE, or the font's line height plus 2 when that is more. */
+    int markSize() const;
     static constexpr int MARGIN = 3;
 
 private:
diff --git a/Apps/Maps/main/Source/ui/MenuIcons.cpp b/Apps/Maps/main/Source/ui/MenuIcons.cpp
new file mode 100644
index 0000000..65c1376
--- /dev/null
+++ b/Apps/Maps/main/Source/ui/MenuIcons.cpp
@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "MenuIcons.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace maps {
+
+namespace {
+
+/**
+ * A pen that draws in a 24 unit grid around the icon's centre, scaled to the real size. Keeping the shapes in grid
+ * units lets one drawing serve every size.
+ */
+struct Pen {
+    Canvas& canvas;
+    float cx;
+    float cy;
+    float scale;
+    float stroke;
+    uint16_t color;
+
+    float x(float gx) const { return cx + gx * scale; }
+    float y(float gy) const { return cy + gy * scale; }
+
+    void line(float x0, float y0, float x1, float y1, float widthFactor = 1.0f) const {
+        canvas.line(x(x0), y(y0), x(x1), y(y1), stroke * widthFactor, color);
+    }
+    void ring(float gx, float gy, float radius) const {
+        canvas.ring(x(gx), y(gy), radius * scale, stroke, color);
+    }
+    void dot(float gx, float gy, float radius) const {
+        canvas.fillCircle(x(gx), y(gy), std::max(radius * scale, stroke * 0.6f), color);
+    }
+    /** A line that stops short of both ends, to leave room for a ring round a node. */
+    void trimmed(float x0, float y0, float x1, float y1, float gapStart, float gapEnd) const {
+        const float dx = x1 - x0;
+        const float dy = y1 - y0;
+        const float length = std::sqrt(dx * dx + dy * dy);
+        if (length <= gapStart + gapEnd) {
+            return;
+        }
+        const float ux = dx / length;
+        const float uy = dy / length;
+        line(x0 + ux * gapStart, y0 + uy * gapStart, x1 - ux * gapEnd, y1 - uy * gapEnd);
+    }
+};
+
+int roundToInt(float value) {
+    return static_cast<int>(std::floor(value + 0.5f));
+}
+
+} // namespace
+
+void drawMenuIcon(Canvas& canvas, MenuIcon icon, int centreX, int centreY, int size, uint16_t color) {
+    const float scale = static_cast<float>(size) / 24.0f;
+    const Pen pen { canvas, static_cast<float>(centreX), static_cast<float>(centreY), scale, std::max(1.5f, static_cast<float>(size) / 12.0f), color };
+    switch (icon) {
+        case MenuIcon::None:
+            break;
+        case MenuIcon::Search:
+            pen.ring(-2.5f, -2.5f, 7.0f);
+            pen.line(2.8f, 2.8f, 10.0f, 10.0f, 1.3f);
+            break;
+        case MenuIcon::Download:
+            pen.line(0.0f, -10.0f, 0.0f, 4.0f);
+            pen.line(-5.5f, -1.5f, 0.0f, 4.5f);
+            pen.line(5.5f, -1.5f, 0.0f, 4.5f);
+            // The tray the file lands in
+            pen.line(-9.0f, 6.0f, -9.0f, 10.0f);
+            pen.line(-9.0f, 10.0f, 9.0f, 10.0f);
+            pen.line(9.0f, 10.0f, 9.0f, 6.0f);
+            break;
+        case MenuIcon::Maps:
+            // A folded sheet: zigzag top and bottom, a fold line between the panels
+            pen.line(-10.0f, -6.0f, -3.5f, -9.0f);
+            pen.line(-3.5f, -9.0f, 3.5f, -6.0f);
+            pen.line(3.5f, -6.0f, 10.0f, -9.0f);
+            pen.line(-10.0f, 9.0f, -3.5f, 6.0f);
+            pen.line(-3.5f, 6.0f, 3.5f, 9.0f);
+            pen.line(3.5f, 9.0f, 10.0f, 6.0f);
+            pen.line(-10.0f, -6.0f, -10.0f, 9.0f);
+            pen.line(-3.5f, -9.0f, -3.5f, 6.0f);
+            pen.line(3.5f, -6.0f, 3.5f, 9.0f);
+            pen.line(10.0f, -9.0f, 10.0f, 6.0f);
+            break;
+        case MenuIcon::Waypoints:
+            pen.ring(0.0f, -4.0f, 6.0f);
+            pen.line(-5.2f, -1.0f, 0.0f, 10.5f);
+            pen.line(5.2f, -1.0f, 0.0f, 10.5f);
+            pen.dot(0.0f, -4.0f, 2.0f);
+            break;
+        case MenuIcon::Track: {
+            // Dots along a bend, ending in a bigger one: where the recording is now
+            const float dots[][2] = { { -9.0f, 9.0f }, { -6.5f, 4.0f }, { -2.5f, 1.0f }, { 2.5f, -1.0f }, { 5.0f, -5.0f } };
+            for (const auto& d : dots) {
+                pen.dot(d[0], d[1], 1.6f);
+            }
+            pen.dot(8.5f, -9.0f, 3.4f);
+            break;
+        }
+        case MenuIcon::Gpx: {
+            const float nodes[][2] = { { -8.0f, 7.0f }, { -1.5f, -5.0f }, { 8.0f, 4.0f } };
+            const float gap = 3.6f;
+            pen.trimmed(nodes[0][0], nodes[0][1], nodes[1][0], nodes[1][1], gap, gap);
+            pen.trimmed(nodes[1][0], nodes[1][1], nodes[2][0], nodes[2][1], gap, gap);
+            for (const auto& n : nodes) {
+                pen.ring(n[0], n[1], 2.6f);
+            }
+            break;
+        }
+        case MenuIcon::Location:
+            pen.ring(0.0f, 0.0f, 6.0f);
+            pen.line(0.0f, -11.0f, 0.0f, -7.5f);
+            pen.line(0.0f, 7.5f, 0.0f, 11.0f);
+            pen.line(-11.0f, 0.0f, -7.5f, 0.0f);
+            pen.line(7.5f, 0.0f, 11.0f, 0.0f);
+            pen.dot(0.0f, 0.0f, 2.2f);
+            break;
+        case MenuIcon::Settings: {
+            const float rows[] = { -7.0f, 0.0f, 7.0f };
+            const float knobs[] = { -4.0f, 4.0f, -1.0f };
+            for (int i = 0; i < 3; i++) {
+                // The slider line leaves a gap for the knob
+                pen.line(-10.0f, rows[i], knobs[i] - 3.8f, rows[i]);
+                pen.line(knobs[i] + 3.8f, rows[i], 10.0f, rows[i]);
+                pen.ring(knobs[i], rows[i], 2.6f);
+            }
+            break;
+        }
+        case MenuIcon::About:
+            pen.ring(0.0f, 0.0f, 10.0f);
+            pen.dot(0.0f, -4.8f, 1.5f);
+            pen.line(0.0f, -1.2f, 0.0f, 5.5f, 1.2f);
+            break;
+        case MenuIcon::Exit:
+            pen.line(-1.0f, -9.0f, -9.0f, -9.0f);
+            pen.line(-9.0f, -9.0f, -9.0f, 9.0f);
+            pen.line(-9.0f, 9.0f, -1.0f, 9.0f);
+            pen.line(-3.0f, 0.0f, 10.0f, 0.0f);
+            pen.line(5.0f, -5.0f, 10.0f, 0.0f);
+            pen.line(5.0f, 5.0f, 10.0f, 0.0f);
+            break;
+        case MenuIcon::Route:
+            pen.ring(-8.0f, 8.0f, 2.8f);
+            pen.line(-8.0f, 5.0f, -8.0f, -1.0f);
+            pen.line(-8.0f, -1.0f, 8.0f, -1.0f);
+            pen.line(8.0f, -1.0f, 8.0f, -5.0f);
+            pen.dot(8.0f, -8.0f, 3.2f);
+            break;
+        case MenuIcon::Stop: {
+            const int side = std::max(8, roundToInt(14.0f * scale));
+            canvas.fillRoundRect(centreX - side / 2, centreY - side / 2, side, side, 1, color);
+            break;
+        }
+        case MenuIcon::Clear:
+            pen.line(-8.0f, -8.0f, 8.0f, 8.0f, 1.2f);
+            pen.line(-8.0f, 8.0f, 8.0f, -8.0f, 1.2f);
+            break;
+        case MenuIcon::Pause: {
+            const int bar = std::max(3, roundToInt(5.0f * scale));
+            const int tall = std::max(8, roundToInt(16.0f * scale));
+            const int gap = std::max(3, roundToInt(4.0f * scale));
+            canvas.fillRoundRect(centreX - gap / 2 - bar, centreY - tall / 2, bar, tall, 1, color);
+            canvas.fillRoundRect(centreX + (gap + 1) / 2, centreY - tall / 2, bar, tall, 1, color);
+            break;
+        }
+    }
+}
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/ui/MenuIcons.h b/Apps/Maps/main/Source/ui/MenuIcons.h
new file mode 100644
index 0000000..d343ae5
--- /dev/null
+++ b/Apps/Maps/main/Source/ui/MenuIcons.h
@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "Canvas.h"
+
+#include <cstdint>
+
+namespace maps {
+
+/** The pictures of the menu entries. */
+enum class MenuIcon : uint8_t {
+    None,
+    Search,
+    Download,
+    Maps,
+    Waypoints,
+    Track,
+    Gpx,
+    Location,
+    Settings,
+    About,
+    Exit,
+    Route,
+    Stop,
+    Clear,
+    Pause
+};
+
+/**
+ * Draws an icon as plain lines in one colour, centred on a point, in a square of size pixels. They are drawn for 24
+ * and still read at 18. Nothing depends on a second colour, so they work on a black and white display.
+ */
+void drawMenuIcon(Canvas& canvas, MenuIcon icon, int centreX, int centreY, int size, uint16_t color);
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/ui/Metrics.h b/Apps/Maps/main/Source/ui/Metrics.h
new file mode 100644
index 0000000..34f4b2c
--- /dev/null
+++ b/Apps/Maps/main/Source/ui/Metrics.h
@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "Canvas.h"
+
+#include <algorithm>
+
+namespace maps {
+
+/**
+ * The sizes and small drawing helpers every widget shares, so a sheet, a card and a list look alike. Widgets used to
+ * carry their own copies of these.
+ */
+namespace metrics {
+
+/** Space between a panel's edge and its content, and between neighbouring buttons. */
+constexpr int PADDING = 8;
+/** Extra height of a list row on top of the font's line height. */
+constexpr int ROW_PADDING = 10;
+/** Corner radius of panels (sheets, cards, dialogs, popups). */
+constexpr int PANEL_RADIUS = 8;
+/** Corner radius of buttons; their border takes 1 px. */
+constexpr int BUTTON_RADIUS = 6;
+/** Corner radius of text fields, outer edge; the inside is one less. */
+constexpr int FIELD_RADIUS = 4;
+/** How much the map is dimmed behind a popup, dialog, card or search sheet. */
+constexpr uint8_t SCRIM_ALPHA = 100;
+
+/** Minimum sizes on boards without a typing keyboard, where a finger is the main input. */
+constexpr int TOUCH_ROW_HEIGHT = 36;
+constexpr int TOUCH_BUTTON_HEIGHT = 36;
+constexpr int TOUCH_BACK_WIDTH = 40;
+
+/**
+ * Whether the board has a typing keyboard. Without one a finger is the main input: rows, buttons and the back area get
+ * the TOUCH_* sizes and no key hints show. With one the compact sizes stay (more rows fit) and sheets show their
+ * shortcuts. Set from the app when the inputs are known; the default is the T-Deck.
+ */
+inline bool& keyboardFlag() {
+    static bool value = true;
+    return value;
+}
+inline void setKeyboard(bool value) { keyboardFlag() = value; }
+inline bool hasKeyboard() { return keyboardFlag(); }
+inline bool touchTargets() { return !keyboardFlag(); }
+
+/** A list row's height: the font's line height plus ROW_PADDING, at least TOUCH_ROW_HEIGHT on touch boards. */
+inline int rowHeight(int lineHeight) {
+    return touchTargets() ? std::max(lineHeight + ROW_PADDING, TOUCH_ROW_HEIGHT) : lineHeight + ROW_PADDING;
+}
+
+/** A button's height: the font's line height plus extra, at least TOUCH_BUTTON_HEIGHT on touch boards. */
+inline int buttonHeight(int lineHeight, int extra = 10) {
+    return touchTargets() ? std::max(lineHeight + extra, TOUCH_BUTTON_HEIGHT) : lineHeight + extra;
+}
+
+/**
+ * The width cap of a card, dialog or sheet: base pixels with the fonts of a 320 px screen, wider with bigger fonts
+ * (14 line heights), so a card keeps its proportions to the text on a big screen. 300 and 280 stay as they are up to a
+ * 21 px line.
+ */
+inline int widthCap(int base, int lineHeight) {
+    return std::max(base, lineHeight * 14);
+}
+
+/**
+ * The width of a card, dialog or sheet on a screen: as wide as the screen allows (minus margin) in portrait, where there
+ * is no room to spare sideways, otherwise capped by widthCap.
+ */
+inline int cardWidth(int screenWidth, int screenHeight, int margin, int base, int lineHeight) {
+    const int room = screenWidth - margin;
+    return screenHeight > screenWidth ? room : std::min(room, widthCap(base, lineHeight));
+}
+
+/** The height of a header bar: the font's line height plus 10, at least TOUCH_HEADER_HEIGHT on touch boards (screens 240 px high or more). */
+constexpr int TOUCH_HEADER_HEIGHT = 40;
+inline int headerHeight(int lineHeight, int extra = 10, int screenHeight = 1000) {
+    // Not on a low screen, where the finger-sized header would take a third of it
+    return touchTargets() && screenHeight >= 240 ? std::max(lineHeight + extra, TOUCH_HEADER_HEIGHT) : lineHeight + extra;
+}
+
+/** The width of a header's back area, from its natural width. */
+inline int backWidth(int natural) {
+    return touchTargets() ? std::max(natural, TOUCH_BACK_WIDTH) : natural;
+}
+
+/** The < of a back button, drawn from lines so it needs no glyph in the font. cx, cy: the centre. */
+inline void drawBackChevron(Canvas& canvas, float cx, float cy, uint16_t color, float reach = 6.0f, float width = 2.0f) {
+    canvas.line(cx + reach / 2.0f, cy - reach, cx - reach / 2.0f, cy, width, color);
+    canvas.line(cx - reach / 2.0f, cy, cx + reach / 2.0f, cy + reach, width, color);
+}
+
+/**
+ * A thin bar at the right edge showing where the visible rows are in a longer list. trackTop/trackHeight: the area the
+ * rows cover; right: the x of the edge the bar sits against.
+ */
+inline void drawScrollbar(Canvas& canvas, int right, int trackTop, int trackHeight, int visibleRows, int totalRows, int firstRow, uint16_t color) {
+    if (totalRows <= visibleRows || visibleRows <= 0) {
+        return;
+    }
+    const int barHeight = std::max(8, trackHeight * visibleRows / totalRows);
+    const int barTop = trackTop + (trackHeight - barHeight) * firstRow / std::max(1, totalRows - visibleRows);
+    canvas.fillRect(right - 3, barTop, 2, barHeight, color);
+}
+
+} // namespace metrics
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/ui/NavigationBar.cpp b/Apps/Maps/main/Source/ui/NavigationBar.cpp
index e2e93ce..630c8a6 100644
--- a/Apps/Maps/main/Source/ui/NavigationBar.cpp
+++ b/Apps/Maps/main/Source/ui/NavigationBar.cpp
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "NavigationBar.h"
 
+#include "Metrics.h"
+
 #include <cmath>
 #include <cstdio>
 #include <initializer_list>
@@ -9,7 +11,7 @@ namespace maps {
 
 namespace {
 
-constexpr int PADDING = 8;
+using metrics::PADDING;
 constexpr float DEGREES_TO_RADIANS = 3.14159265f / 180.0f;
 constexpr float ARROW_WIDTH = 3.0f;
 
@@ -75,6 +77,16 @@ bool NavigationBar::stopHit(int x, int y) const {
         y < stopArea.y + stopArea.height + 6;
 }
 
+Rect NavigationBar::stopRect(Font& font, int width) const {
+    const int size = height(font) - 12;
+    return { width - size - 6, (height(font) - size) / 2, size, size };
+}
+
+Rect NavigationBar::stopHitRect(Font& font, int width) const {
+    const Rect r = stopRect(font, width);
+    return { r.x - 6, 0, r.width + 12, r.y + r.height + 6 };
+}
+
 int NavigationBar::height(Font& font) const {
     return 2 * font.lineHeight() + PADDING + 4;
 }
@@ -146,8 +158,8 @@ void NavigationBar::draw(Canvas& canvas, Font& font, const UiTheme& theme, int w
     stopArea = {};
     if (stopShown) {
         // An X on a framed square at the right end
-        const int size = barHeight - 12;
-        stopArea = { width - size - 6, (barHeight - size) / 2, size, size };
+        stopArea = stopRect(font, width);
+        const int size = stopArea.width;
         canvas.fillRoundRect(stopArea.x, stopArea.y, size, size, 6, theme.border);
         canvas.fillRoundRect(stopArea.x + 1, stopArea.y + 1, size - 2, size - 2, 5, theme.panel);
         const float cx = static_cast<float>(stopArea.x) + size / 2.0f;
diff --git a/Apps/Maps/main/Source/ui/NavigationBar.h b/Apps/Maps/main/Source/ui/NavigationBar.h
index 8d40061..d898b12 100644
--- a/Apps/Maps/main/Source/ui/NavigationBar.h
+++ b/Apps/Maps/main/Source/ui/NavigationBar.h
@@ -29,6 +29,10 @@ class NavigationBar {
     bool stopHit(int x, int y) const;
     Turn turn() const { return nextTurn; }
 
+    /** For tests: the drawn stop button and the area stopHit() accepts, for a bar of this width. */
+    Rect stopRect(Font& font, int width) const;
+    Rect stopHitRect(Font& font, int width) const;
+
     /** Two text lines and padding; the arrow area is this high and wide. */
     int height(Font& font) const;
     /** A full-width panel at the top of the canvas. */
diff --git a/Apps/Maps/main/Source/ui/RouteCard.cpp b/Apps/Maps/main/Source/ui/RouteCard.cpp
index dc6d14b..8f8437e 100644
--- a/Apps/Maps/main/Source/ui/RouteCard.cpp
+++ b/Apps/Maps/main/Source/ui/RouteCard.cpp
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "RouteCard.h"
 
+#include "Metrics.h"
+
 #include <algorithm>
 #include <cstdio>
 
@@ -8,10 +10,15 @@ namespace maps {
 
 namespace {
 
-constexpr int PADDING = 8;
+using metrics::PADDING;
+
 /** The mode bar: segments of this size, this far below the top of the screen. */
 constexpr int MODE_WIDTH = 52;
 constexpr int MODE_HEIGHT = 30;
+
+int modeHeight() {
+    return metrics::touchTargets() ? metrics::TOUCH_BUTTON_HEIGHT : MODE_HEIGHT;
+}
 constexpr int MODE_TOP = 4;
 
 const char* labelOf(RouteCard::Button button) {
@@ -94,13 +101,26 @@ RouteCard::Button RouteCard::pressed(Button button) const {
 
 void RouteCard::layout(int width, int height, Font& font) {
     const int line = font.lineHeight();
-    const int cardWidth = std::min(width - 8, 300);
+    const int cardWidth = metrics::cardWidth(width, height, 8, 300, line);
     noteLineCount = 0;
     if (noteText[0] != '\0') {
         noteLineCount = wrapText(font, noteText, cardWidth - 2 * PADDING, &noteLines[0][0], NOTE_LINE_LENGTH, NOTE_LINES);
     }
-    const int buttonHeight = line + 10;
-    const int cardHeight = PADDING + line + 4 + noteLineCount * line + (noteLineCount > 0 ? 4 : 0) + buttonHeight + PADDING;
+    const int buttonHeight = metrics::buttonHeight(line);
+    // With a keyboard one more muted line lists the shortcuts
+    const int hintHeight = metrics::hasKeyboard() ? line + 2 : 0;
+    int cardHeight = PADDING + line + 4 + noteLineCount * line + (noteLineCount > 0 ? 4 : 0) + hintHeight + buttonHeight + PADDING;
+    // A low screen: the card must stay under the mode bar, so the hint and then the note lines go
+    const int cardRoom = height - 4 - (MODE_TOP + modeHeight() + 8) - 2;
+    showHint = hintHeight > 0;
+    if (cardHeight > cardRoom && showHint) {
+        cardHeight -= hintHeight;
+        showHint = false;
+    }
+    while (cardHeight > cardRoom && noteLineCount > 0) {
+        noteLineCount--;
+        cardHeight -= line + (noteLineCount == 0 ? 4 : 0);
+    }
     frame = { (width - cardWidth) / 2, height - cardHeight - 4, cardWidth, cardHeight };
     const int buttonWidth = (cardWidth - 3 * PADDING) / 2;
     const int buttonY = frame.y + cardHeight - PADDING - buttonHeight;
@@ -108,20 +128,20 @@ void RouteCard::layout(int width, int height, Font& font) {
         buttons[i] = { frame.x + PADDING + i * (buttonWidth + PADDING), buttonY, buttonWidth, buttonHeight };
     }
     const int barWidth = MODE_COUNT * MODE_WIDTH + (MODE_COUNT + 1) * 4;
-    modeBar = { (width - barWidth) / 2, MODE_TOP, barWidth, MODE_HEIGHT + 8 };
+    modeBar = { (width - barWidth) / 2, MODE_TOP, barWidth, modeHeight() + 8 };
     for (int i = 0; i < MODE_COUNT; i++) {
-        modes[i] = { modeBar.x + 4 + i * (MODE_WIDTH + 4), modeBar.y + 4, MODE_WIDTH, MODE_HEIGHT };
+        modes[i] = { modeBar.x + 4 + i * (MODE_WIDTH + 4), modeBar.y + 4, MODE_WIDTH, modeHeight() };
     }
 }
 
 void RouteCard::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
     // The modes: the chosen one filled, the focused one framed
-    canvas.fillRoundRect(modeBar.x, modeBar.y, modeBar.width, modeBar.height, 8, theme.panel, theme.panelOpacity);
+    canvas.fillRoundRect(modeBar.x, modeBar.y, modeBar.width, modeBar.height, metrics::PANEL_RADIUS, theme.panel, theme.panelOpacity);
     for (int i = 0; i < MODE_COUNT; i++) {
         const Rect& r = modes[i];
         const bool chosen = i == mode;
         if (chosen) {
-            canvas.fillRoundRect(r.x, r.y, r.width, r.height, 6, theme.accent);
+            canvas.fillRoundRect(r.x, r.y, r.width, r.height, metrics::BUTTON_RADIUS, theme.accent);
         }
         if (focus == i) {
             canvas.frameRect(r.x - 1, r.y - 1, r.width + 2, r.height + 2, chosen ? theme.text : theme.accent, 2);
@@ -130,7 +150,7 @@ void RouteCard::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
     }
     const int line = font.lineHeight();
     const int textWidth = frame.width - 2 * PADDING;
-    canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, 8, theme.panel, theme.panelOpacity);
+    canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, metrics::PANEL_RADIUS, theme.panel, theme.panelOpacity);
     int textY = frame.y + PADDING;
     drawClippedText(canvas, font, frame.x + PADDING, textY, busy ? "Finding a route..." : summaryText, textWidth, theme.text);
     textY += line + 4;
@@ -138,14 +158,17 @@ void RouteCard::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
         drawClippedText(canvas, font, frame.x + PADDING, textY, noteLines[i], textWidth, theme.muted);
         textY += line;
     }
+    if (showHint) {
+        drawClippedText(canvas, font, frame.x + PADDING, textY, "W/B/C: mode  S: start  P: profile", textWidth, theme.muted);
+    }
     for (int i = 0; i < 2; i++) {
         const Button button = buttonAt(FOCUS_START + i);
         // Start without a route to start is drawn muted, framed when it has the focus
         if (button == Button::Start && (busy || !canStart)) {
             const bool focused = focus == FOCUS_START;
-            canvas.fillRoundRect(buttons[i].x, buttons[i].y, buttons[i].width, buttons[i].height, 6, focused ? theme.accent : theme.border);
+            canvas.fillRoundRect(buttons[i].x, buttons[i].y, buttons[i].width, buttons[i].height, metrics::BUTTON_RADIUS, focused ? theme.accent : theme.border);
             canvas.fillRoundRect(buttons[i].x + (focused ? 2 : 1), buttons[i].y + (focused ? 2 : 1), buttons[i].width - (focused ? 4 : 2),
-                buttons[i].height - (focused ? 4 : 2), 5, theme.panel);
+                buttons[i].height - (focused ? 4 : 2), metrics::BUTTON_RADIUS - 1, theme.panel);
             const int labelWidth = font.textWidth(labelOf(button));
             font.drawText(canvas, buttons[i].x + (buttons[i].width - labelWidth) / 2, buttons[i].y + (buttons[i].height - line) / 2, labelOf(button),
                 theme.muted);
diff --git a/Apps/Maps/main/Source/ui/RouteCard.h b/Apps/Maps/main/Source/ui/RouteCard.h
index e31db34..9327e0e 100644
--- a/Apps/Maps/main/Source/ui/RouteCard.h
+++ b/Apps/Maps/main/Source/ui/RouteCard.h
@@ -59,6 +59,9 @@ class RouteCard {
     bool contains(int x, int y) const { return frame.contains(x, y) || modeBar.contains(x, y); }
     const Rect& bounds() const { return frame; }
     const Rect& modeBounds() const { return modeBar; }
+    /** For tests: a mode's segment, and the Start (0) and Close (1) buttons. */
+    const Rect& modeRect(int index) const { return modes[index]; }
+    const Rect& buttonRect(int index) const { return buttons[index]; }
 
     /**
      * Tab and arrows move the focus over the modes and the buttons, Enter presses the focused one, W, B, C (or 1, 2, 3)
@@ -83,6 +86,7 @@ class RouteCard {
     int mode = 0;
     int focus = FOCUS_START;
     int noteLineCount = 0;
+    bool showHint = true;
     char summaryText[SUMMARY_LENGTH] = "";
     char noteText[NOTE_LENGTH] = "";
     char noteLines[NOTE_LINES][NOTE_LINE_LENGTH] {};
diff --git a/Apps/Maps/main/Source/ui/SearchSheet.cpp b/Apps/Maps/main/Source/ui/SearchSheet.cpp
index b20f820..b3f6eed 100644
--- a/Apps/Maps/main/Source/ui/SearchSheet.cpp
+++ b/Apps/Maps/main/Source/ui/SearchSheet.cpp
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "SearchSheet.h"
 
+#include "Metrics.h"
+
 #include <algorithm>
 #include <cmath>
 #include <cstdio>
@@ -11,8 +13,7 @@ namespace maps {
 
 namespace {
 
-constexpr int PADDING = 8;
-constexpr int ROW_PADDING = 10;
+using metrics::PADDING;
 constexpr const char* PLACEHOLDER = "Search places, streets, addresses";
 constexpr const char* CATEGORY_ENTRY = "Nearby by category";
 
@@ -184,7 +185,7 @@ const SearchSheet::Slot* SearchSheet::slotOf(int entry) const {
 int SearchSheet::entryHeight(int entry) const {
     const Slot* slot = slotOf(entry);
     if (slot == nullptr || compact) {
-        return lineHeight + ROW_PADDING;
+        return metrics::rowHeight(lineHeight);
     }
     return 2 * lineHeight + 6 + (slot->note[0] != '\0' ? lineHeight : 0);
 }
@@ -231,7 +232,7 @@ void SearchSheet::keepVisible() {
 }
 
 void SearchSheet::relayout() {
-    barHeight = lineHeight + 12;
+    barHeight = metrics::touchTargets() ? std::max(lineHeight + 12, metrics::TOUCH_BUTTON_HEIGHT) : lineHeight + 12;
     const int headerHeight = headerText[0] != '\0' ? lineHeight + 2 : 2;
     listTop = barHeight + headerHeight;
     const int hintHeight = typing && !compact ? lineHeight + 4 : 0;
@@ -243,9 +244,10 @@ void SearchSheet::layout(int width, int height, Font& font, bool compactLayout)
     compact = compactLayout;
     lineHeight = font.lineHeight();
     frame = { 0, 0, width, height };
-    barHeight = lineHeight + 12;
-    backButton = { 0, 0, lineHeight + 16, barHeight };
-    field = { backButton.width, 3, width - backButton.width - 6, lineHeight + 8 };
+    barHeight = metrics::touchTargets() ? std::max(lineHeight + 12, metrics::TOUCH_BUTTON_HEIGHT) : lineHeight + 12;
+    backButton = { 0, 0, metrics::backWidth(lineHeight + 16), barHeight };
+    // Centred in the bar, which is 28 px with the 16 px font (the field starts 3 px down)
+    field = { backButton.width, 3 + (barHeight - (lineHeight + 12)) / 2, width - backButton.width - 6, lineHeight + 8 };
     relayout();
 }
 
@@ -301,18 +303,17 @@ void SearchSheet::drawArrow(Canvas& canvas, float cx, float cy, float degrees, u
 
 void SearchSheet::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
     // The map stays visible but dimmed behind the sheet, as behind the menus
-    canvas.fillRect(0, 0, canvas.width, canvas.height, theme.scrim, 90);
+    canvas.fillRect(0, 0, canvas.width, canvas.height, theme.scrim, metrics::SCRIM_ALPHA);
     canvas.fillRect(frame.x, frame.y, frame.width, frame.height, theme.panel, theme.panelOpacity);
 
     // < at the top left, drawn as lines
     const auto backX = static_cast<float>(backButton.x + backButton.width / 2);
     const auto backY = static_cast<float>(field.y + field.height / 2);
-    canvas.line(backX + 3.0f, backY - 6.0f, backX - 3.0f, backY, 2.0f, theme.text);
-    canvas.line(backX - 3.0f, backY, backX + 3.0f, backY + 6.0f, 2.0f, theme.text);
+    metrics::drawBackChevron(canvas, backX, backY, theme.text);
 
     // The text field: the end of a long text stays in view; with the placeholder when empty
-    canvas.fillRoundRect(field.x, field.y, field.width, field.height, 4, focusField ? theme.accent : theme.border);
-    canvas.fillRoundRect(field.x + 1, field.y + 1, field.width - 2, field.height - 2, 3, theme.panel);
+    canvas.fillRoundRect(field.x, field.y, field.width, field.height, metrics::FIELD_RADIUS, focusField ? theme.accent : theme.border);
+    canvas.fillRoundRect(field.x + 1, field.y + 1, field.width - 2, field.height - 2, metrics::FIELD_RADIUS - 1, theme.panel);
     if (value[0] == '\0') {
         drawClippedText(canvas, font, field.x + 4, field.y + 4, categoryView ? CATEGORY_ENTRY : PLACEHOLDER, field.width - 8, theme.muted);
         if (focusField) {
@@ -412,17 +413,14 @@ void SearchSheet::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
     }
 
     // A thin bar shows where the visible rows are in a longer list
-    if (shownRows > 0 && shownRows < count) {
-        const int trackHeight = y - listTop;
-        const int barLength = std::max(8, trackHeight * shownRows / count);
-        const int barTop = listTop + (trackHeight - barLength) * first / std::max(1, maxFirst());
-        canvas.fillRect(frame.width - 3, barTop, 2, barLength, theme.muted);
+    if (shownRows > 0) {
+        metrics::drawScrollbar(canvas, frame.width, listTop, y - listTop, shownRows, count, first, theme.muted);
     }
 
     if (typing && !compact) {
         const int hintY = frame.height - lineHeight - 2;
         canvas.fillRect(0, hintY - 2, frame.width, 1, theme.border);
-        drawClippedText(canvas, font, PADDING, hintY, "Roll: choose  Enter: open  Esc: close", frame.width - 2 * PADDING, theme.muted);
+        drawClippedText(canvas, font, PADDING, hintY, trackball ? "Roll: choose  Enter: open  Esc: close" : "Tab: list  Enter: open  Esc: close", frame.width - 2 * PADDING, theme.muted);
     }
 }
 
@@ -575,10 +573,13 @@ SearchSheet::Event SearchSheet::handleKey(uint32_t key) {
             return {};
         case keys::BACKSPACE:
         case keys::DELETE:
-            if (categoryView || resultView || value[0] == '\0') {
+            // Backspace in a field with text always deletes; on an empty field it goes back like Esc
+            if (value[0] == '\0') {
                 return goBack();
             }
             erase();
+            categoryView = false;
+            resultView = false;
             selection = 0;
             first = 0;
             highlighted = typing;
diff --git a/Apps/Maps/main/Source/ui/SearchSheet.h b/Apps/Maps/main/Source/ui/SearchSheet.h
index ba61d72..f3472e8 100644
--- a/Apps/Maps/main/Source/ui/SearchSheet.h
+++ b/Apps/Maps/main/Source/ui/SearchSheet.h
@@ -79,6 +79,8 @@ class SearchSheet {
     /** Boards with a typing keyboard show key hints and highlight the selection from the start. */
     void setTypingKeyboard(bool value);
     bool hasTypingKeyboard() const { return typing; }
+    /** Whether the board has a trackball: the footer then says "Roll" for moving through the rows, else "Tab". */
+    void setTrackball(bool value) { trackball = value; }
 
     const char* text() const { return value; }
     /** Replaces the text without an event (for example a recent search). */
@@ -111,6 +113,8 @@ class SearchSheet {
     void draw(Canvas& canvas, Font& font, const UiTheme& theme);
     const Rect& bounds() const { return frame; }
     const Rect& fieldBounds() const { return field; }
+    /** For tests: the < area. */
+    const Rect& backRect() const { return backButton; }
     bool fieldFocused() const { return focusField; }
 
     Event handleKey(uint32_t key);
@@ -165,6 +169,7 @@ class SearchSheet {
 
     bool visible = false;
     bool typing = false;
+    bool trackball = true;
     bool compact = false;
     bool focusField = true;
     bool highlighted = false;
diff --git a/Apps/Maps/main/Source/ui/Settings.cpp b/Apps/Maps/main/Source/ui/Settings.cpp
index 4a80514..2cbcd99 100644
--- a/Apps/Maps/main/Source/ui/Settings.cpp
+++ b/Apps/Maps/main/Source/ui/Settings.cpp
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "Settings.h"
 
+#include "../platform/SafeFile.h"
+
 #include "../tiles/TileMath.h"
 
 #include <cstdio>
@@ -52,16 +54,17 @@ bool writeTextFile(const char* path, const char* text) {
     }
     const size_t length = strlen(text);
     const bool ok = fwrite(text, 1, length, file) == length;
-    fclose(file);
-    remove(path);
-    if (!ok || rename(temporary, path) != 0) {
+    // The old file goes only once the new one is whole (a failed write must not cost the old one)
+    if (fclose(file) != 0 || !ok) {
         remove(temporary);
         return false;
     }
-    return true;
+    // A failed replace keeps the temporary file: the old one may be gone already, and recoverFile() needs it
+    return replaceFile(temporary, path);
 }
 
 bool readTextFile(const char* path, char* text, size_t size) {
+    recoverFile(path);
     FILE* file = fopen(path, "r");
     if (file == nullptr) {
         return false;
diff --git a/Apps/Maps/main/Source/ui/TileGrid.cpp b/Apps/Maps/main/Source/ui/TileGrid.cpp
new file mode 100644
index 0000000..6a2579b
--- /dev/null
+++ b/Apps/Maps/main/Source/ui/TileGrid.cpp
@@ -0,0 +1,627 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "TileGrid.h"
+
+#include "Metrics.h"
+
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+namespace maps {
+
+namespace {
+
+constexpr int MARGIN = 6;
+constexpr int GAP = 4;
+constexpr int TILE_RADIUS = 8;
+constexpr int DOT_SPACING = 12;
+
+/** Text centred in a width, cut with ".." when it does not fit. */
+void drawCentredText(Canvas& canvas, Font& font, int x, int y, int width, const char* text, uint16_t color) {
+    const int textWidth = font.textWidth(text);
+    if (textWidth > width) {
+        drawClippedText(canvas, font, x, y, text, width, color);
+    } else {
+        font.drawText(canvas, x + (width - textWidth) / 2, y, text, color);
+    }
+}
+
+/** The outline of a tile or status item: a border and a panel inside, or a solid accent when focused. */
+void drawFrame(Canvas& canvas, const Rect& r, bool focused, int radius, const UiTheme& theme) {
+    if (focused) {
+        canvas.fillRoundRect(r.x, r.y, r.width, r.height, radius, theme.accent);
+        return;
+    }
+    canvas.fillRoundRect(r.x, r.y, r.width, r.height, radius, theme.border);
+    canvas.fillRoundRect(r.x + 1, r.y + 1, r.width - 2, r.height - 2, radius - 1, theme.panel);
+}
+
+} // namespace
+
+void TileGrid::clear() {
+    tiles = 0;
+    statuses = 0;
+    corner.label[0] = '\0';
+    zone = Zone::Tile;
+    focusIndex = 0;
+    currentPage = 0;
+}
+
+void TileGrid::setTitle(const char* text) {
+    snprintf(title, sizeof(title), "%s", text != nullptr ? text : "");
+}
+
+void TileGrid::setGrid(int columnCount, int rowCount) {
+    columns = std::clamp(columnCount, 1, 6);
+    rows = std::clamp(rowCount, 1, 6);
+    usedRows = rows;
+    currentPage = 0;
+    keepFocusValid();
+}
+
+int TileGrid::addTile(uint16_t action, MenuIcon icon, const char* label, const char* detail) {
+    if (tiles >= MAX_TILES) {
+        return -1;
+    }
+    Tile& tile = tileList[tiles];
+    tile.action = action;
+    tile.icon = icon;
+    snprintf(tile.label, LABEL_LENGTH, "%s", label != nullptr ? label : "");
+    snprintf(tile.detail, LABEL_LENGTH, "%s", detail != nullptr ? detail : "");
+    return tiles++;
+}
+
+void TileGrid::setDetail(uint16_t action, const char* detail) {
+    for (int i = 0; i < tiles; i++) {
+        if (tileList[i].action == action) {
+            snprintf(tileList[i].detail, LABEL_LENGTH, "%s", detail != nullptr ? detail : "");
+            return;
+        }
+    }
+}
+
+void TileGrid::addStatus(uint16_t action, MenuIcon icon, const char* text) {
+    if (statuses >= MAX_STATUS) {
+        return;
+    }
+    Status& status = statusList[statuses++];
+    status.action = action;
+    status.icon = icon;
+    snprintf(status.text, STATUS_LENGTH, "%s", text != nullptr ? text : "");
+}
+
+void TileGrid::setCorner(uint16_t action, const char* label) {
+    corner.action = action;
+    snprintf(corner.label, LABEL_LENGTH, "%s", label != nullptr ? label : "");
+}
+
+void TileGrid::setHint(const char* text) {
+    snprintf(hint, sizeof(hint), "%s", text != nullptr ? text : "");
+}
+
+int TileGrid::pageCount() const {
+    return tiles > 0 ? (tiles + perPage() - 1) / perPage() : 1;
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+
+void TileGrid::layout(int width, int height, Font& font, Font* smallFont) {
+    Font& small = smallFont != nullptr ? *smallFont : font;
+    mainFont = &font;
+    smallFontPtr = &small;
+    screenWidth = width;
+    screenHeight = height;
+    const int line = font.lineHeight();
+
+    // The header is the one of ListView's full screen lists
+    header = headerLayout(0, 0, width, metrics::headerHeight(line, 10, height));
+    if (hasCorner()) {
+        const int buttonHeight = metrics::touchTargets() && height >= 240 ? std::max(header.bar.height - 8, metrics::TOUCH_BUTTON_HEIGHT) : header.bar.height - 8;
+        const int buttonWidth = small.textWidth(corner.label) + 16;
+        cornerBox = { width - MARGIN - buttonWidth, (header.bar.height - 1 - buttonHeight) / 2, buttonWidth, buttonHeight };
+    } else {
+        cornerBox = { 0, 0, 0, 0 };
+    }
+
+    int top = header.bar.height + MARGIN;
+    int stripHeight = 0;
+    if (statuses > 0) {
+        stripHeight = metrics::touchTargets() && height >= 240 ? std::max(line + 12, metrics::TOUCH_BUTTON_HEIGHT) : line + 12;
+        top += stripHeight + GAP;
+    }
+
+    // From the bottom up: hint line, page dots, then the grid takes what is left
+    int bottom = height - 3;
+    hintY = 0;
+    if (hint[0] != '\0') {
+        hintY = height - small.lineHeight() - 3;
+        bottom = hintY - 1;
+    }
+
+    // Tiles never get lower than a label with an icon needs; a lower screen shows fewer rows per page
+    const int minTile = line + 14;
+    auto fitRows = [&](int room) {
+        int fit = rows;
+        while (fit > 1 && (room - GAP * (fit - 1)) / fit < minTile) {
+            fit--;
+        }
+        return fit;
+    };
+    dotsY = 0;
+    usedRows = fitRows(bottom - 3 - top);
+    if (pageCount() > 1) {
+        dotsY = bottom - 5;
+        bottom -= 10;
+        usedRows = fitRows(bottom - 3 - top);
+    }
+    const int gridBottom = bottom - 3;
+    const int availableHeight = gridBottom - top;
+
+    // A tile is at most 8 x 7 line heights: more would be a slab with a small icon in it
+    const int availableWidth = width - 2 * MARGIN;
+    const int fullWidth = std::max(8, (availableWidth - GAP * (columns - 1)) / columns);
+    const int fullHeight = std::max(8, (availableHeight - GAP * (usedRows - 1)) / usedRows);
+    tileWidth = std::min(fullWidth, 8 * line);
+    tileHeight = std::min(fullHeight, 7 * line);
+    const bool capped = tileWidth < fullWidth || tileHeight < fullHeight;
+    gridLeft = MARGIN + (availableWidth - columns * tileWidth - GAP * (columns - 1)) / 2;
+    int gridTop = top;
+    if (tileHeight < fullHeight) {
+        gridTop += (availableHeight - (usedRows * tileHeight + GAP * (usedRows - 1))) / 2;
+    }
+    gridBox = { gridLeft, gridTop, columns * tileWidth + GAP * (columns - 1), usedRows * tileHeight + GAP * (usedRows - 1) };
+    if (statuses > 0) {
+        // The strip is as wide as the grid under it
+        const int stripLeft = capped ? gridBox.x : MARGIN;
+        stripBox = { stripLeft, header.bar.height + MARGIN, capped ? gridBox.width : width - 2 * MARGIN, stripHeight };
+    } else {
+        stripBox = { 0, 0, 0, 0 };
+    }
+    keepFocusValid();
+}
+
+Rect TileGrid::tileRect(int index) const {
+    if (index < 0 || index >= tiles) {
+        return { 0, 0, 0, 0 };
+    }
+    const int local = index % perPage();
+    return { gridLeft + (local % columns) * (tileWidth + GAP), gridBox.y + (local / columns) * (tileHeight + GAP), tileWidth, tileHeight };
+}
+
+Rect TileGrid::statusRect(int index) const {
+    if (index < 0 || index >= statuses) {
+        return { 0, 0, 0, 0 };
+    }
+    const int width = (stripBox.width - GAP * (statuses - 1)) / statuses;
+    return { stripBox.x + index * (width + GAP), stripBox.y, width, stripBox.height };
+}
+
+void TileGrid::draw(Canvas& canvas, Font& font, const UiTheme& theme) const {
+    Font& small = smallFontPtr != nullptr ? *smallFontPtr : font;
+
+    // Opaque: the map's scale bar and labels showed through between the tiles and under the hint
+    canvas.fillRect(0, 0, canvas.width, canvas.height, theme.panel, 255);
+
+    // The title stops before the corner button; the line under the header runs the full width
+    HeaderLayout bar = header;
+    if (hasCorner()) {
+        bar.bar.width = cornerBox.x - 2;
+        canvas.fillRect(bar.bar.width, header.bar.height - 1, canvas.width - bar.bar.width, 1, theme.border);
+    }
+    drawHeader(canvas, font, theme, bar, title, false);
+    if (hasCorner()) {
+        drawButton(canvas, small, theme, cornerBox, corner.label, shown && zone == Zone::Corner);
+    }
+
+    for (int i = 0; i < statuses; i++) {
+        const Rect r = statusRect(i);
+        const bool focused = shown && zone == Zone::Status && focusIndex == i;
+        const uint16_t color = focused ? theme.accentText : theme.text;
+        drawFrame(canvas, r, focused, 7, theme);
+        const int statusIcon = std::min(18 * std::max(16, font.lineHeight()) / 16, r.height - 6);
+        drawMenuIcon(canvas, statusList[i].icon, r.x + 5 + statusIcon / 2, r.y + r.height / 2, statusIcon, color);
+        const int textX = r.x + 5 + statusIcon + 4;
+        drawClippedText(canvas, small, textX, r.y + (r.height - small.lineHeight()) / 2, statusList[i].text, r.x + r.width - 4 - textX, color);
+    }
+
+    // A detail slot is kept free on every tile when any tile has a detail, so icons in a row line up
+    bool anyDetail = false;
+    for (int i = 0; i < tiles; i++) {
+        anyDetail = anyDetail || tileList[i].detail[0] != '\0';
+    }
+    // The icon grows with the font, and shrinks when the tile is too low for it and a label
+    int iconSize = (tileHeight < 52 ? 18 : 24) * std::max(16, font.lineHeight()) / 16;
+    iconSize = std::max(10, std::min(iconSize, tileHeight - 4 - 2 - font.lineHeight()));
+    const int withDetail = iconSize + 2 + font.lineHeight() + 1 + small.lineHeight();
+    const bool reserve = anyDetail && withDetail <= tileHeight - 4;
+    const int content = reserve ? withDetail : iconSize + 2 + font.lineHeight();
+
+    const int first = currentPage * perPage();
+    const int last = std::min(tiles, first + perPage());
+    for (int i = first; i < last; i++) {
+        const Rect r = tileRect(i);
+        const Tile& tile = tileList[i];
+        const bool focused = shown && zone == Zone::Tile && focusIndex == i;
+        const uint16_t color = focused ? theme.accentText : theme.text;
+        drawFrame(canvas, r, focused, TILE_RADIUS, theme);
+        const int top = r.y + (r.height - content) / 2;
+        const int labelY = top + iconSize + 2;
+        const uint16_t detailColor = focused ? theme.accentText : theme.muted;
+        if (!reserve && tile.detail[0] != '\0') {
+            // Too low for a third line: the detail goes beside the icon, the pair centred
+            const int room = r.width - 6 - iconSize - 4;
+            const int detailWidth = std::min(small.textWidth(tile.detail), room);
+            const int left = r.x + (r.width - (iconSize + 4 + detailWidth)) / 2;
+            drawMenuIcon(canvas, tile.icon, left + iconSize / 2, top + iconSize / 2, iconSize, color);
+            drawClippedText(canvas, small, left + iconSize + 4, top + (iconSize - small.lineHeight()) / 2, tile.detail, detailWidth, detailColor);
+        } else {
+            drawMenuIcon(canvas, tile.icon, r.x + r.width / 2, top + iconSize / 2, iconSize, color);
+        }
+        // A label too wide for the tile takes the small font before it is cut
+        Font& labelFont = font.textWidth(tile.label) > r.width - 6 && small.textWidth(tile.label) <= r.width - 6 ? small : font;
+        drawCentredText(canvas, labelFont, r.x + 3, labelY + (font.lineHeight() - labelFont.lineHeight()) / 2, r.width - 6, tile.label, color);
+        if (reserve && tile.detail[0] != '\0') {
+            drawCentredText(canvas, small, r.x + 3, labelY + font.lineHeight() + 1, r.width - 6, tile.detail, detailColor);
+        }
+    }
+
+    if (dotsY > 0) {
+        const int count = pageCount();
+        const int left = canvas.width / 2 - (count - 1) * DOT_SPACING / 2;
+        for (int i = 0; i < count; i++) {
+            const auto x = static_cast<float>(left + i * DOT_SPACING);
+            if (i == currentPage) {
+                canvas.fillCircle(x, static_cast<float>(dotsY), 3.0f, theme.text);
+            } else {
+                canvas.ring(x, static_cast<float>(dotsY), 2.5f, 1.2f, theme.muted);
+            }
+        }
+    }
+    if (hintY > 0) {
+        drawCentredText(canvas, small, MARGIN, hintY, canvas.width - 2 * MARGIN, hint, theme.muted);
+    }
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+
+void TileGrid::keepFocusValid() {
+    currentPage = std::clamp(currentPage, 0, pageCount() - 1);
+    const bool valid = (zone == Zone::Corner && hasCorner()) || (zone == Zone::Status && focusIndex < statuses) ||
+        (zone == Zone::Tile && focusIndex < tiles);
+    if (!valid) {
+        if (tiles > 0) {
+            zone = Zone::Tile;
+            focusIndex = std::min(focusIndex, tiles - 1);
+        } else if (statuses > 0) {
+            zone = Zone::Status;
+            focusIndex = 0;
+        } else {
+            zone = hasCorner() ? Zone::Corner : Zone::Tile;
+            focusIndex = 0;
+        }
+    }
+    if (zone == Zone::Tile && tiles > 0) {
+        // Keep the page the focus is on, a grid refilled with fewer tiles may have lost its page
+        focusIndex = std::clamp(focusIndex, 0, tiles - 1);
+        currentPage = focusIndex / perPage();
+    }
+}
+
+uint16_t TileGrid::focusAction() const {
+    switch (zone) {
+        case Zone::Corner:
+            return hasCorner() ? corner.action : NO_ACTION;
+        case Zone::Status:
+            return focusIndex < statuses ? statusList[focusIndex].action : NO_ACTION;
+        case Zone::Tile:
+            return focusIndex < tiles ? tileList[focusIndex].action : NO_ACTION;
+    }
+    return NO_ACTION;
+}
+
+void TileGrid::setFocusAction(uint16_t action, bool show) {
+    shown = show;
+    for (int i = 0; i < tiles; i++) {
+        if (tileList[i].action == action) {
+            moveFocusTo(Zone::Tile, i);
+            return;
+        }
+    }
+    for (int i = 0; i < statuses; i++) {
+        if (statusList[i].action == action) {
+            moveFocusTo(Zone::Status, i);
+            return;
+        }
+    }
+    if (hasCorner() && corner.action == action) {
+        moveFocusTo(Zone::Corner, 0);
+    }
+}
+
+bool TileGrid::moveFocusTo(Zone newZone, int index) {
+    const bool changed = newZone != zone || index != focusIndex;
+    zone = newZone;
+    focusIndex = index;
+    if (zone == Zone::Tile) {
+        currentPage = index / perPage();
+    }
+    return changed;
+}
+
+void TileGrid::focusNearestTile(int centreX) {
+    const int first = currentPage * perPage();
+    int best = first;
+    int bestDistance = 1 << 30;
+    for (int c = 0; c < columns && first + c < tiles; c++) {
+        const Rect r = tileRect(first + c);
+        const int distance = std::abs(r.x + r.width / 2 - centreX);
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = first + c;
+        }
+    }
+    moveFocusTo(Zone::Tile, best);
+}
+
+void TileGrid::focusNearestStatus(int centreX) {
+    int best = 0;
+    int bestDistance = 1 << 30;
+    for (int i = 0; i < statuses; i++) {
+        const Rect r = statusRect(i);
+        const int distance = std::abs(r.x + r.width / 2 - centreX);
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = i;
+        }
+    }
+    moveFocusTo(Zone::Status, best);
+}
+
+bool TileGrid::stepTile(int dx, int dy) {
+    const int pp = perPage();
+    const int i = focusIndex;
+    const int page = i / pp;
+    const int row = (i % pp) / columns;
+    const int column = i % columns;
+    if (dx > 0) {
+        if (column < columns - 1 && i + 1 < tiles) {
+            return moveFocusTo(Zone::Tile, i + 1);
+        }
+        if ((page + 1) * pp < tiles) {
+            // Next page, same row, first column (or the last tile when that row is not filled)
+            return moveFocusTo(Zone::Tile, std::min((page + 1) * pp + row * columns, tiles - 1));
+        }
+        return false;
+    }
+    if (dx < 0) {
+        if (column > 0) {
+            return moveFocusTo(Zone::Tile, i - 1);
+        }
+        if (page > 0) {
+            return moveFocusTo(Zone::Tile, (page - 1) * pp + row * columns + columns - 1);
+        }
+        return false;
+    }
+    if (dy > 0) {
+        if (row < usedRows - 1) {
+            const int below = std::min(i + columns, tiles - 1);
+            return below > i && moveFocusTo(Zone::Tile, below);
+        }
+        return false;
+    }
+    if (row > 0) {
+        return moveFocusTo(Zone::Tile, i - columns);
+    }
+    const Rect r = tileRect(i);
+    if (statuses > 0) {
+        focusNearestStatus(r.x + r.width / 2);
+        return true;
+    }
+    if (hasCorner()) {
+        return moveFocusTo(Zone::Corner, 0);
+    }
+    return false;
+}
+
+bool TileGrid::step(int dx, int dy) {
+    switch (zone) {
+        case Zone::Tile:
+            return stepTile(dx, dy);
+        case Zone::Status:
+            if (dx != 0) {
+                const int next = std::clamp(focusIndex + dx, 0, statuses - 1);
+                return moveFocusTo(Zone::Status, next);
+            }
+            if (dy < 0) {
+                return hasCorner() && moveFocusTo(Zone::Corner, 0);
+            }
+            if (tiles > 0) {
+                const Rect r = statusRect(focusIndex);
+                focusNearestTile(r.x + r.width / 2);
+                return true;
+            }
+            return false;
+        case Zone::Corner:
+            if (dy > 0) {
+                if (statuses > 0) {
+                    focusNearestStatus(cornerBox.x + cornerBox.width / 2);
+                    return true;
+                }
+                if (tiles > 0) {
+                    focusNearestTile(cornerBox.x + cornerBox.width / 2);
+                    return true;
+                }
+            }
+            return false;
+    }
+    return false;
+}
+
+bool TileGrid::move(int dx, int dy) {
+    if (dx == 0 && dy == 0) {
+        return false;
+    }
+    keepFocusValid();
+    if (!shown) {
+        // The first step shows the highlight where the focus is, it does not move yet
+        shown = true;
+        return true;
+    }
+    return step(dx, dy);
+}
+
+int TileGrid::ordinalCount() const {
+    return (hasCorner() ? 1 : 0) + statuses + tiles;
+}
+
+int TileGrid::ordinalOf(Zone z, int index) const {
+    const int cornerCount = hasCorner() ? 1 : 0;
+    switch (z) {
+        case Zone::Corner:
+            return 0;
+        case Zone::Status:
+            return cornerCount + index;
+        case Zone::Tile:
+            return cornerCount + statuses + index;
+    }
+    return 0;
+}
+
+void TileGrid::focusOrdinal(int ordinal) {
+    const int cornerCount = hasCorner() ? 1 : 0;
+    if (ordinal < cornerCount) {
+        moveFocusTo(Zone::Corner, 0);
+    } else if (ordinal < cornerCount + statuses) {
+        moveFocusTo(Zone::Status, ordinal - cornerCount);
+    } else {
+        moveFocusTo(Zone::Tile, ordinal - cornerCount - statuses);
+    }
+}
+
+GridEvent TileGrid::chosen() const {
+    const uint16_t action = focusAction();
+    if (action == NO_ACTION) {
+        return { GridResult::None, 0 };
+    }
+    return { GridResult::Chosen, action };
+}
+
+GridEvent TileGrid::handleKey(uint32_t key) {
+    const GridEvent none { GridResult::None, 0 };
+    switch (key) {
+        case 'w':
+        case 'W':
+        case keys::UP:
+            move(0, -1);
+            return none;
+        case 's':
+        case 'S':
+        case keys::DOWN:
+            move(0, 1);
+            return none;
+        case 'a':
+        case 'A':
+        case keys::LEFT:
+            move(-1, 0);
+            return none;
+        case 'd':
+        case 'D':
+        case keys::RIGHT:
+            move(1, 0);
+            return none;
+        case keys::TAB:
+        case keys::FOCUS_NEXT:
+        case keys::FOCUS_PREVIOUS: {
+            keepFocusValid();
+            const int count = ordinalCount();
+            if (!shown) {
+                shown = true;
+            } else if (count > 0) {
+                const int direction = key == keys::FOCUS_PREVIOUS ? count - 1 : 1;
+                focusOrdinal((ordinalOf(zone, focusIndex) + direction) % count);
+            }
+            return none;
+        }
+        case keys::ENTER:
+        case ' ':
+        case keys::YES:
+            if (!shown) {
+                shown = true;
+                return none;
+            }
+            return chosen();
+        case keys::ESCAPE:
+        case keys::BACKSPACE:
+        case keys::NO:
+        case 'm':
+        case 'M':
+            return { GridResult::Back, 0 };
+        default:
+            return none;
+    }
+}
+
+bool TileGrid::pick(int x, int y, Zone& pickedZone, int& index) const {
+    if (hasCorner() && cornerBox.contains(x, y)) {
+        pickedZone = Zone::Corner;
+        index = 0;
+        return true;
+    }
+    for (int i = 0; i < statuses; i++) {
+        if (statusRect(i).contains(x, y)) {
+            pickedZone = Zone::Status;
+            index = i;
+            return true;
+        }
+    }
+    const int first = currentPage * perPage();
+    const int last = std::min(tiles, first + perPage());
+    for (int i = first; i < last; i++) {
+        if (tileRect(i).contains(x, y)) {
+            pickedZone = Zone::Tile;
+            index = i;
+            return true;
+        }
+    }
+    return false;
+}
+
+GridEvent TileGrid::handleTap(int x, int y) {
+    if (header.back.contains(x, y)) {
+        return { GridResult::Back, 0 };
+    }
+    Zone pickedZone;
+    int index;
+    if (!pick(x, y, pickedZone, index)) {
+        return { GridResult::None, 0 };
+    }
+    // The focus follows the tap without showing the highlight, as ListView::select does
+    moveFocusTo(pickedZone, index);
+    return chosen();
+}
+
+void TileGrid::hover(int x, int y) {
+    Zone pickedZone;
+    int index;
+    if (pick(x, y, pickedZone, index)) {
+        moveFocusTo(pickedZone, index);
+        shown = true;
+    }
+}
+
+bool TileGrid::swipe(int direction) {
+    const int target = std::clamp(currentPage + (direction < 0 ? -1 : 1), 0, pageCount() - 1);
+    if (target == currentPage || direction == 0) {
+        return false;
+    }
+    currentPage = target;
+    if (zone == Zone::Tile) {
+        // The focus stays in the same place of the new page
+        const int local = focusIndex % perPage();
+        focusIndex = std::min(target * perPage() + local, tiles - 1);
+    }
+    return true;
+}
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/ui/TileGrid.h b/Apps/Maps/main/Source/ui/TileGrid.h
new file mode 100644
index 0000000..e720c71
--- /dev/null
+++ b/Apps/Maps/main/Source/ui/TileGrid.h
@@ -0,0 +1,169 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "Canvas.h"
+#include "MenuIcons.h"
+#include "Widgets.h"
+
+#include <cstdint>
+
+namespace maps {
+
+/** What an input did to a tile grid. */
+enum class GridResult : uint8_t {
+    None,
+    Chosen,
+    Back
+};
+
+struct GridEvent {
+    GridResult result;
+    /** The action of the chosen tile, status item or corner button; only set when result is Chosen. */
+    uint16_t action;
+};
+
+/**
+ * A full screen menu of tiles (an icon with a label under it) in a grid, a 2-D neighbour of ListView. Under the header
+ * with its back chevron and an optional corner button it can show a strip of up to three status items (a running
+ * download, the route), then the tiles, page dots when the tiles need more than one page, and a hint line.
+ *
+ * Tiles are at most about 8 x 7 line heights and the grid is centred, so a big screen shows a compact menu rather than
+ * slabs; on a screen too low for readable tiles a page shows fewer rows and the rest moves to more pages.
+ *
+ * One focus moves over three zones: the corner button, the status strip and the tiles. As in ListView the highlight
+ * stays hidden until the first key or trackball step, and touch never shows it.
+ */
+class TileGrid {
+public:
+    static constexpr int MAX_TILES = 24;
+    static constexpr int MAX_STATUS = 3;
+    static constexpr int LABEL_LENGTH = 16;
+    static constexpr int STATUS_LENGTH = 28;
+    static constexpr int TITLE_LENGTH = 32;
+    static constexpr int HINT_LENGTH = 64;
+    /** What focusAction() returns when nothing can be focused. */
+    static constexpr uint16_t NO_ACTION = 0xFFFF;
+
+    /**
+     * Removes the tiles, status items and the corner button and puts the focus on the first tile. The title, hint, grid
+     * size and the shown highlight stay, so a menu filled again keeps them.
+     */
+    void clear();
+    void setTitle(const char* text);
+    void setGrid(int columns, int rows);
+    /** Returns the tile's index, -1 when full. */
+    int addTile(uint16_t action, MenuIcon icon, const char* label, const char* detail = nullptr);
+    /** Changes the small text of the tile with this action. An empty or null text removes it. */
+    void setDetail(uint16_t action, const char* detail);
+    /** Adds a status item to the strip (up to three). Without any, the strip is not shown. */
+    void addStatus(uint16_t action, MenuIcon icon, const char* text);
+    /** A button at the right end of the header; a null label removes it. */
+    void setCorner(uint16_t action, const char* label);
+    /** A line at the very bottom; a null or empty text removes it. */
+    void setHint(const char* hint);
+
+    /** Computes the rectangles. The small font is for details, the hint and the corner button (default: font). */
+    void layout(int width, int height, Font& font, Font* smallFont = nullptr);
+    /** Uses the fonts given to layout(), which must still exist. */
+    void draw(Canvas& canvas, Font& font, const UiTheme& theme) const;
+
+    /** Arrows and WASD move, Tab goes through everything in reading order, Enter and Space choose, Esc, Backspace and M go back. */
+    GridEvent handleKey(uint32_t key);
+    /** A tap on a tile, status item or the corner button chooses it, the back chevron goes back. */
+    GridEvent handleTap(int x, int y);
+    /** Pointer mode: the item under the pointer gets the focus and shows as hovered. */
+    void hover(int x, int y);
+    /** Moves the focus one step (trackball). The first step only shows the highlight. Returns whether anything changed. */
+    bool move(int dx, int dy);
+    /** Shows the previous (-1) or next (+1) page, for touch drags. Returns whether the page changed. */
+    bool swipe(int direction);
+
+    /** The action under the focus, NO_ACTION when there is nothing. */
+    uint16_t focusAction() const;
+    /** Puts the focus on the item with this action, to remember the last one; the page follows. */
+    void setFocusAction(uint16_t action, bool shown);
+    bool focusShown() const { return shown; }
+
+    Rect tileRect(int index) const;
+    Rect statusRect(int index) const;
+    Rect cornerRect() const { return cornerBox; }
+    /** For tests: the header's back area, the rows a page shows after layout(), the columns, and the grid's box. */
+    const Rect& backRect() const { return header.back; }
+    int shownRows() const { return usedRows; }
+    int shownColumns() const { return columns; }
+    const Rect& gridBounds() const { return gridBox; }
+    const Rect& stripBounds() const { return stripBox; }
+    int tileCount() const { return tiles; }
+    int statusCount() const { return statuses; }
+    int page() const { return currentPage; }
+    int pageCount() const;
+
+private:
+    enum class Zone : uint8_t { Corner, Status, Tile };
+
+    struct Tile {
+        uint16_t action;
+        MenuIcon icon;
+        char label[LABEL_LENGTH];
+        char detail[LABEL_LENGTH];
+    };
+
+    struct Status {
+        uint16_t action;
+        MenuIcon icon;
+        char text[STATUS_LENGTH];
+    };
+
+    int perPage() const { return columns * usedRows; }
+    bool hasCorner() const { return corner.label[0] != '\0'; }
+    int ordinalCount() const;
+    int ordinalOf(Zone zone, int index) const;
+    void focusOrdinal(int ordinal);
+    void keepFocusValid();
+    void focusNearestTile(int centreX);
+    void focusNearestStatus(int centreX);
+    bool step(int dx, int dy);
+    bool stepTile(int dx, int dy);
+    bool moveFocusTo(Zone zone, int index);
+    bool pick(int x, int y, Zone& zone, int& index) const;
+    GridEvent chosen() const;
+
+    struct Corner {
+        uint16_t action = 0;
+        char label[LABEL_LENGTH] = "";
+    };
+
+    Tile tileList[MAX_TILES] {};
+    Status statusList[MAX_STATUS] {};
+    Corner corner {};
+    int tiles = 0;
+    int statuses = 0;
+    int columns = 3;
+    int rows = 3;
+    /** The rows a page really shows: rows, fewer when the screen is too low for readable tiles (more pages then). */
+    int usedRows = 3;
+    char title[TITLE_LENGTH] = "";
+    char hint[HINT_LENGTH] = "";
+
+    Zone zone = Zone::Tile;
+    int focusIndex = 0;
+    int currentPage = 0;
+    bool shown = false;
+
+    // Set by layout()
+    int screenWidth = 0;
+    int screenHeight = 0;
+    HeaderLayout header {};
+    Rect cornerBox {};
+    Rect stripBox {};
+    Rect gridBox {};
+    int tileWidth = 0;
+    int tileHeight = 0;
+    int gridLeft = 0;
+    int dotsY = 0;
+    int hintY = 0;
+    Font* mainFont = nullptr;
+    Font* smallFontPtr = nullptr;
+};
+
+} // namespace maps
diff --git a/Apps/Maps/main/Source/ui/TouchKeyboard.cpp b/Apps/Maps/main/Source/ui/TouchKeyboard.cpp
index 91175ac..8b3f12d 100644
--- a/Apps/Maps/main/Source/ui/TouchKeyboard.cpp
+++ b/Apps/Maps/main/Source/ui/TouchKeyboard.cpp
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "TouchKeyboard.h"
 
+#include <algorithm>
 #include <cstdio>
 #include <cstring>
 
@@ -59,8 +60,16 @@ void encode(uint32_t code, char* out) {
 
 } // namespace
 
-int TouchKeyboard::heightFor(int /*width*/) {
-    return GAP + ROWS * KEY_HEIGHT + (ROWS - 1) * GAP;
+int TouchKeyboard::keyHeightFor(int height, int lineHeight) {
+    // Wanted: a key a finger can hit, growing with the font and the screen but never beyond 3 lines of text
+    const int wanted = std::min(std::max({ KEY_HEIGHT, lineHeight * 7 / 4, height / 10 }), std::max(KEY_HEIGHT, lineHeight * 3));
+    // Room: the keyboard takes at most 8/15 of the screen, which is 128 of 240 px
+    const int room = (height * 8 / 15 - GAP - (ROWS - 1) * GAP) / ROWS;
+    return std::max(14, std::min(wanted, room));
+}
+
+int TouchKeyboard::heightFor(int /*width*/, int height, int lineHeight) {
+    return GAP + ROWS * keyHeightFor(height, lineHeight) + (ROWS - 1) * GAP;
 }
 
 void TouchKeyboard::open() {
@@ -70,15 +79,16 @@ void TouchKeyboard::open() {
     build();
 }
 
-void TouchKeyboard::layout(int width, int height, Font& /*font*/) {
+void TouchKeyboard::layout(int width, int height, Font& font) {
     screenWidth = width;
-    const int keyboardHeight = heightFor(width);
+    keyHeight = keyHeightFor(height, font.lineHeight());
+    const int keyboardHeight = heightFor(width, height, font.lineHeight());
     area = { 0, height - keyboardHeight, width, keyboardHeight };
     build();
 }
 
 void TouchKeyboard::beginRow(int row, int offsetUnits) {
-    rowY = area.y + GAP + row * (KEY_HEIGHT + GAP);
+    rowY = area.y + GAP + row * (keyHeight + GAP);
     rowCursor = offsetUnits;
 }
 
@@ -91,7 +101,7 @@ void TouchKeyboard::add(Kind kind, uint32_t code, const char* label, int units)
     const int left = GAP + rowCursor * span / ROW_UNITS;
     const int right = GAP + (rowCursor + units) * span / ROW_UNITS - GAP;
     Key& key = keys_[keyCount++];
-    key.rect = { left, rowY, right - left, KEY_HEIGHT };
+    key.rect = { left, rowY, right - left, keyHeight };
     key.kind = kind;
     key.code = code;
     snprintf(key.label, sizeof(key.label), "%s", label);
diff --git a/Apps/Maps/main/Source/ui/TouchKeyboard.h b/Apps/Maps/main/Source/ui/TouchKeyboard.h
index 8335727..47aefeb 100644
--- a/Apps/Maps/main/Source/ui/TouchKeyboard.h
+++ b/Apps/Maps/main/Source/ui/TouchKeyboard.h
@@ -15,15 +15,21 @@ namespace maps {
  */
 class TouchKeyboard {
 public:
-    /** Height it takes at the bottom of a screen of this width (4 rows of 30 px, 2 px gaps and edges): 128 px. */
-    static int heightFor(int width);
+    /**
+     * Height it takes at the bottom of a screen: 4 rows of keys with 2 px gaps and edges. Keys are 30 px (128 px in all)
+     * on a 240 px high screen with the 16 px font, taller with a bigger font or a taller screen, and lower on a short
+     * screen so the keyboard never takes more than about half of it. The defaults are the T-Deck's screen.
+     */
+    static int heightFor(int width, int height = 240, int lineHeight = 16);
+    /** The height of one key for that screen (heightFor is four of them plus the gaps). */
+    static int keyHeightFor(int height, int lineHeight);
 
     /** Opens on the letters page, lower case. */
     void open();
     void close() { visible = false; }
     bool isOpen() const { return visible; }
 
-    /** Fills the bottom heightFor(width) pixels of a screen of width x height. */
+    /** Fills the bottom heightFor(width, height, font's line height) pixels of a screen of width x height. */
     void layout(int width, int height, Font& font);
     void draw(Canvas& canvas, Font& font, const UiTheme& theme);
     /** The keyboard's area, false when it is closed. */
@@ -39,6 +45,11 @@ class TouchKeyboard {
     bool keyCentre(const char* label, int& x, int& y) const;
     /** For tests: the rectangle of that key. */
     bool keyRect(const char* label, Rect& rect) const;
+    /** For tests: the keyboard's area. */
+    const Rect& bounds() const { return area; }
+    /** For tests: how many keys the current page has, and the rectangle of key i. */
+    int keyTotal() const { return keyCount; }
+    const Rect& keyBounds(int index) const { return keys_[index].rect; }
 
 private:
     enum class Page : uint8_t { Letters, Symbols, Accents };
@@ -66,6 +77,7 @@ class TouchKeyboard {
     Page page = Page::Letters;
     Shift shift = Shift::Off;
     int screenWidth = 0;
+    int keyHeight = 30;
     Rect area {};
     Key keys_[MAX_KEYS] {};
     int keyCount = 0;
diff --git a/Apps/Maps/main/Source/ui/WaypointSheet.cpp b/Apps/Maps/main/Source/ui/WaypointSheet.cpp
index 01114c3..2a40dee 100644
--- a/Apps/Maps/main/Source/ui/WaypointSheet.cpp
+++ b/Apps/Maps/main/Source/ui/WaypointSheet.cpp
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "WaypointSheet.h"
 
+#include "Metrics.h"
+
 #include <algorithm>
 #include <cstdio>
 #include <cstring>
@@ -9,7 +11,7 @@ namespace maps {
 
 namespace {
 
-constexpr int PADDING = 8;
+using metrics::PADDING;
 
 const char* labelOf(WaypointSheet::Button button) {
     switch (button) {
@@ -32,6 +34,18 @@ const char* labelOf(WaypointSheet::Button button) {
     }
 }
 
+/** The shortcuts of a sheet, from handleKey; shown with a typing keyboard. */
+const char* hintOf(WaypointSheet::Mode mode, bool editable) {
+    switch (mode) {
+        case WaypointSheet::Mode::Existing:
+            return "R: rename  X: delete  N: go";
+        case WaypointSheet::Mode::Place:
+            return "N: go  S: save  Esc: close";
+        default:
+            return editable ? "Type a name  Tab: next button" : "Tab: next button  Esc: cancel";
+    }
+}
+
 } // namespace
 
 void WaypointSheet::openNew(const char* defaultName, const char* coordinates, const char* distance, bool canEdit) {
@@ -91,31 +105,52 @@ WaypointSheet::Button WaypointSheet::buttonAt(int index) const {
 void WaypointSheet::layout(int width, int height, Font& font, bool compact) {
     compactLayout = compact;
     const int line = font.lineHeight();
-    const int sheetWidth = std::min(width - 8, 300);
-    const int buttonHeight = line + 10;
-    const int sheetHeight = PADDING + (line + 8) + 4 + (compact ? 0 : textLines() * line) + (compact ? 0 : PADDING) + buttonHeight + PADDING;
-    frame = { (width - sheetWidth) / 2, height - sheetHeight - 4, sheetWidth, sheetHeight };
+    const int sheetWidth = metrics::cardWidth(width, height, 8, 300, line);
+    const int buttonHeight = metrics::buttonHeight(line);
+    // With a keyboard one more muted line lists the shortcuts, unless the on-screen keyboard needs the room
+    const int hintHeight = metrics::hasKeyboard() && !compact ? line : 0;
+    const int sheetHeight = PADDING + (line + 8) + 4 + (compact ? 0 : textLines() * line) + (compact ? 0 : PADDING) + hintHeight + buttonHeight + PADDING;
+    // On a very low screen the sheet is cut at the top rather than the screen. Above the on-screen keyboard (compact)
+    // the buttons must stay inside the room given: the gaps shrink to the least that keeps the name field above them.
+    const int tightHeight = PADDING / 2 + 2 + (line + 8) + 2 + buttonHeight + PADDING / 2;
+    const int shownHeight = compact ? std::min(sheetHeight, std::max(tightHeight, height - 4)) : sheetHeight;
+    const int bottomGap = shownHeight < sheetHeight ? PADDING / 2 : PADDING;
+    frame = { (width - sheetWidth) / 2, std::max(0, height - shownHeight - 4), sheetWidth, shownHeight };
     // The < at the left of the name goes back, like in the lists
-    back = { frame.x, frame.y, line + 16, line + 8 + PADDING };
+    back = { frame.x, frame.y, metrics::backWidth(line + 16), metrics::touchTargets() ? std::max(line + 8 + PADDING, metrics::TOUCH_BUTTON_HEIGHT) : line + 8 + PADDING };
     field = { frame.x + back.width, frame.y + PADDING / 2 + 2, sheetWidth - back.width - PADDING, line + 8 };
     const int count = buttonCount();
     const int buttonWidth = (sheetWidth - (count + 1) * PADDING) / count;
-    const int buttonY = frame.y + sheetHeight - PADDING - buttonHeight;
+    const int buttonY = frame.y + frame.height - bottomGap - buttonHeight;
+    // Equal buttons; when a label does not fit its button, the room is shared in proportion to the labels
+    int needed = 0;
+    int labelTotal = 0;
     for (int i = 0; i < count; i++) {
-        buttons[i] = { frame.x + PADDING + i * (buttonWidth + PADDING), buttonY, buttonWidth, buttonHeight };
+        const int w = font.textWidth(labelOf(buttonAt(i))) + 8;
+        needed = std::max(needed, w);
+        labelTotal += w;
+    }
+    const int room = sheetWidth - (count + 1) * PADDING;
+    int x = frame.x + PADDING;
+    for (int i = 0; i < count; i++) {
+        int w = buttonWidth;
+        if (needed > buttonWidth && labelTotal > 0) {
+            w = (font.textWidth(labelOf(buttonAt(i))) + 8) * room / labelTotal;
+        }
+        buttons[i] = { x, buttonY, w, buttonHeight };
+        x += w + PADDING;
     }
 }
 
 void WaypointSheet::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
     const int line = font.lineHeight();
-    canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, 8, theme.panel, theme.panelOpacity);
+    canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, metrics::PANEL_RADIUS, theme.panel, theme.panelOpacity);
     const auto backX = static_cast<float>(back.x + back.width / 2);
     const auto backY = static_cast<float>(field.y + field.height / 2);
-    canvas.line(backX + 3.0f, backY - 6.0f, backX - 3.0f, backY, 2.0f, theme.text);
-    canvas.line(backX - 3.0f, backY, backX + 3.0f, backY + 6.0f, 2.0f, theme.text);
+    metrics::drawBackChevron(canvas, backX, backY, theme.text);
     if (editable) {
-        canvas.fillRoundRect(field.x, field.y, field.width, field.height, 4, theme.border);
-        canvas.fillRoundRect(field.x + 1, field.y + 1, field.width - 2, field.height - 2, 3, theme.panel);
+        canvas.fillRoundRect(field.x, field.y, field.width, field.height, metrics::FIELD_RADIUS, theme.border);
+        canvas.fillRoundRect(field.x + 1, field.y + 1, field.width - 2, field.height - 2, metrics::FIELD_RADIUS - 1, theme.panel);
         // The end of a long name stays in view
         const char* shown = value;
         while (*shown != '\0' && font.textWidth(shown) > field.width - 12) {
@@ -145,6 +180,9 @@ void WaypointSheet::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
     if (!compactLayout) {
         drawClippedText(canvas, font, frame.x + PADDING, textY, coordinateText, frame.width - 2 * PADDING, theme.muted);
         drawClippedText(canvas, font, frame.x + PADDING, textY + line, distanceText, frame.width - 2 * PADDING, theme.muted);
+        if (metrics::hasKeyboard()) {
+            drawClippedText(canvas, font, frame.x + PADDING, textY + 2 * line, hintOf(kind, editable), frame.width - 2 * PADDING, theme.muted);
+        }
     }
     for (int i = 0; i < buttonCount(); i++) {
         drawButton(canvas, font, theme, buttons[i], labelOf(buttonAt(i)), i == focus, buttonAt(i) == Button::Delete);
@@ -242,6 +280,10 @@ WaypointSheet::Button WaypointSheet::handleKey(uint32_t key) {
         return key == keys::BACKSPACE ? Button::Cancel : Button::None;
     }
     if (key == keys::BACKSPACE || key == keys::DELETE) {
+        // Backspace deletes while the name has text; on an empty name it cancels, like Esc
+        if (key == keys::BACKSPACE && value[0] == '\0') {
+            return Button::Cancel;
+        }
         erase();
         return Button::None;
     }
diff --git a/Apps/Maps/main/Source/ui/WaypointSheet.h b/Apps/Maps/main/Source/ui/WaypointSheet.h
index 28e88b8..e72fbd8 100644
--- a/Apps/Maps/main/Source/ui/WaypointSheet.h
+++ b/Apps/Maps/main/Source/ui/WaypointSheet.h
@@ -59,6 +59,11 @@ class WaypointSheet {
     void draw(Canvas& canvas, Font& font, const UiTheme& theme);
     bool contains(int x, int y) const { return frame.contains(x, y); }
     const Rect& bounds() const { return frame; }
+    /** For tests: the < area, the name field and the buttons (buttonTotal() of them). */
+    const Rect& backRect() const { return back; }
+    const Rect& fieldRect() const { return field; }
+    const Rect& buttonRect(int index) const { return buttons[index]; }
+    int buttonTotal() const { return buttonCount(); }
 
     /** Typing edits the name of a new waypoint; Enter presses the focused button, Tab and arrows move the focus. */
     Button handleKey(uint32_t key);
diff --git a/Apps/Maps/main/Source/ui/Widgets.cpp b/Apps/Maps/main/Source/ui/Widgets.cpp
index bbc2916..6b352d6 100644
--- a/Apps/Maps/main/Source/ui/Widgets.cpp
+++ b/Apps/Maps/main/Source/ui/Widgets.cpp
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "Widgets.h"
 
+#include "Metrics.h"
+
 #include <algorithm>
 #include <cstdio>
 #include <cstring>
@@ -9,24 +11,31 @@ namespace maps {
 
 namespace {
 
-constexpr int PADDING = 8;
-constexpr int ROW_PADDING = 10;
+using metrics::PADDING;
+using metrics::ROW_PADDING;
 
 } // namespace
 
 void drawButton(Canvas& canvas, Font& font, const UiTheme& theme, const Rect& rect, const char* label, bool focused, bool danger) {
     const uint16_t fill = focused ? (danger ? theme.danger : theme.accent) : theme.panel;
     const uint16_t text = focused ? (danger ? theme.dangerText : theme.accentText) : theme.text;
-    canvas.fillRoundRect(rect.x, rect.y, rect.width, rect.height, 6, focused ? fill : theme.border);
+    canvas.fillRoundRect(rect.x, rect.y, rect.width, rect.height, metrics::BUTTON_RADIUS, focused ? fill : theme.border);
     if (!focused) {
-        canvas.fillRoundRect(rect.x + 1, rect.y + 1, rect.width - 2, rect.height - 2, 5, fill);
+        canvas.fillRoundRect(rect.x + 1, rect.y + 1, rect.width - 2, rect.height - 2, metrics::BUTTON_RADIUS - 1, fill);
     }
     const int width = font.textWidth(label);
-    font.drawText(canvas, rect.x + (rect.width - width) / 2, rect.y + (rect.height - font.lineHeight()) / 2, label, text);
+    const int y = rect.y + (rect.height - font.lineHeight()) / 2;
+    if (width > rect.width - 4) {
+        // A narrow button: the label is cut instead of running over its edges
+        drawClippedText(canvas, font, rect.x + 2, y, label, rect.width - 4, text);
+        return;
+    }
+    font.drawText(canvas, rect.x + (rect.width - width) / 2, y, label, text);
 }
 
 HeaderLayout headerLayout(int x, int y, int width, int height) {
-    const int button = height + 8;
+    // At least a finger wide on boards without a keyboard
+    const int button = metrics::backWidth(height + 8);
     return { { x, y, width, height }, { x, y, button, height }, { x + width - button, y, button, height } };
 }
 
@@ -34,8 +43,7 @@ void drawHeader(Canvas& canvas, Font& font, const UiTheme& theme, const HeaderLa
     // Drawn as lines, so they need no glyphs in the font
     const auto backX = static_cast<float>(header.back.x + header.back.width / 2);
     const auto centerY = static_cast<float>(header.bar.y + header.bar.height / 2 - 1);
-    canvas.line(backX + 3.0f, centerY - 6.0f, backX - 3.0f, centerY, 2.0f, theme.text);
-    canvas.line(backX - 3.0f, centerY, backX + 3.0f, centerY + 6.0f, 2.0f, theme.text);
+    metrics::drawBackChevron(canvas, backX, centerY, theme.text);
     const int titleX = header.back.x + header.back.width;
     const int titleRight = hasSelect ? header.select.x : header.bar.x + header.bar.width - PADDING;
     drawClippedText(canvas, font, titleX, header.bar.y + (header.bar.height - font.lineHeight()) / 2 - 1, title, titleRight - titleX, theme.text);
@@ -78,6 +86,15 @@ void ListView::setDetail(int index, const char* detail) {
     }
 }
 
+void ListView::setDescriptions(const char* const* texts, int count) {
+    descriptions = texts;
+    descriptionCount = texts != nullptr ? count : 0;
+}
+
+int ListView::descriptionHeight(Font& font) const {
+    return descriptions != nullptr && fullScreen ? font.lineHeight() + 2 : 0;
+}
+
 void ListView::select(int index) {
     selection = std::clamp(index, 0, std::max(0, itemCount - 1));
     keepVisible();
@@ -98,21 +115,23 @@ void ListView::keepVisible() {
 
 void ListView::layoutFullScreen(int width, int height, Font& font) {
     fullScreen = true;
-    rowPixels = font.lineHeight() + ROW_PADDING;
+    rowPixels = metrics::rowHeight(font.lineHeight());
     frame = { 0, 0, width, height };
     // Header on top, hint at the bottom, rows in between
-    listTop = font.lineHeight() + PADDING + 4;
+    listTop = metrics::headerHeight(font.lineHeight(), 10, height) + 2;
     header = headerLayout(0, 0, width, listTop - 2);
-    const int hintHeight = hint[0] != '\0' ? hintLines() * font.lineHeight() + 4 : 0;
+    const int hintHeight = (hint[0] != '\0' ? hintLines() * font.lineHeight() + 4 : 0) + descriptionHeight(font);
     visibleRows = std::max(1, (height - listTop - hintHeight) / rowPixels);
     keepVisible();
 }
 
 void ListView::layoutPopup(int width, int height, Font& font, int popupWidth) {
     fullScreen = false;
-    rowPixels = font.lineHeight() + ROW_PADDING;
-    const int headerHeight = font.lineHeight() + PADDING;
+    rowPixels = metrics::rowHeight(font.lineHeight());
+    const int headerHeight = metrics::headerHeight(font.lineHeight(), PADDING, height);
     const int maxRows = std::max(1, (height - 2 * PADDING - headerHeight) / rowPixels);
+    // Wider with a bigger font, never wider than the screen
+    popupWidth = height > width ? width - 16 : std::min(std::max(popupWidth, popupWidth * font.lineHeight() / 16), width - 16);
     visibleRows = std::min(std::max(1, itemCount), maxRows);
     const int popupHeight = headerHeight + visibleRows * rowPixels + PADDING / 2 + 2;
     frame = { (width - popupWidth) / 2, (height - popupHeight) / 2, popupWidth, popupHeight };
@@ -126,8 +145,8 @@ void ListView::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
         canvas.fillRect(frame.x, frame.y, frame.width, frame.height, theme.panel);
     } else {
         // The map stays visible but dimmed behind a popup
-        canvas.fillRect(0, 0, canvas.width, canvas.height, theme.scrim, 90);
-        canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, 8, theme.panel, theme.panelOpacity);
+        canvas.fillRect(0, 0, canvas.width, canvas.height, theme.scrim, metrics::SCRIM_ALPHA);
+        canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, metrics::PANEL_RADIUS, theme.panel, theme.panelOpacity);
     }
     drawHeader(canvas, font, theme, header, title, itemCount > 0 && highlighted);
     if (itemCount == 0 && hint[0] != '\0' && fullScreen) {
@@ -152,12 +171,11 @@ void ListView::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
         }
     }
     // A thin bar shows where the visible rows are in a longer list
-    if (itemCount > visibleRows) {
-        const int trackTop = frame.y + listTop;
-        const int trackHeight = visibleRows * rowPixels;
-        const int barHeight = std::max(8, trackHeight * visibleRows / itemCount);
-        const int barTop = trackTop + (trackHeight - barHeight) * firstVisible / std::max(1, itemCount - visibleRows);
-        canvas.fillRect(frame.x + frame.width - 3, barTop, 2, barHeight, theme.muted);
+    metrics::drawScrollbar(canvas, frame.x + frame.width, frame.y + listTop, visibleRows * rowPixels, visibleRows, itemCount, firstVisible, theme.muted);
+    if (fullScreen && highlighted && descriptions != nullptr && selection < descriptionCount) {
+        // What the highlighted row does, right above the hint
+        const int hintHeight = hint[0] != '\0' ? hintLines() * font.lineHeight() + 4 : 0;
+        drawClippedText(canvas, font, PADDING, frame.height - hintHeight - font.lineHeight() - 2, descriptions[selection], frame.width - 2 * PADDING, theme.muted);
     }
     if (fullScreen && hint[0] != '\0') {
         int y = frame.height - hintLines() * font.lineHeight() - 2;
@@ -235,6 +253,14 @@ UiAction ListView::handleKey(uint32_t key) {
     }
 }
 
+bool ListView::rowRect(int index, Rect& rect) const {
+    if (index < firstVisible || index >= firstVisible + visibleRows || index >= itemCount) {
+        return false;
+    }
+    rect = { frame.x + 4, frame.y + listTop + (index - firstVisible) * rowPixels, frame.width - 8, rowPixels - 2 };
+    return true;
+}
+
 int ListView::rowAt(int x, int y) const {
     if (!frame.contains(x, y)) {
         return -1;
@@ -279,9 +305,9 @@ void Dialog::open(const char* message, const char* confirmLabel, bool isDanger)
 }
 
 void Dialog::layout(int width, int height, Font& font) {
-    const int dialogWidth = std::min(width - 16, 280);
+    const int dialogWidth = metrics::cardWidth(width, height, 16, 280, font.lineHeight());
     lineCount = wrapText(font, text, dialogWidth - 2 * PADDING, &lines[0][0], sizeof(lines[0]), 3);
-    const int buttonHeight = font.lineHeight() + 12;
+    const int buttonHeight = metrics::buttonHeight(font.lineHeight(), 12);
     const int dialogHeight = PADDING + lineCount * font.lineHeight() + PADDING + buttonHeight + PADDING;
     frame = { (width - dialogWidth) / 2, (height - dialogHeight) / 2, dialogWidth, dialogHeight };
     const int buttonWidth = (dialogWidth - 3 * PADDING) / 2;
@@ -291,8 +317,8 @@ void Dialog::layout(int width, int height, Font& font) {
 }
 
 void Dialog::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
-    canvas.fillRect(0, 0, canvas.width, canvas.height, theme.scrim, 110);
-    canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, 8, theme.panel);
+    canvas.fillRect(0, 0, canvas.width, canvas.height, theme.scrim, metrics::SCRIM_ALPHA);
+    canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, metrics::PANEL_RADIUS, theme.panel, theme.panelOpacity);
     for (int i = 0; i < lineCount; i++) {
         font.drawText(canvas, frame.x + PADDING, frame.y + PADDING + i * font.lineHeight(), lines[i], theme.text);
     }
@@ -317,6 +343,7 @@ UiAction Dialog::handleKey(uint32_t key) {
         case 'a':
         case 'A':
         case 'd':
+        case 'D':
         case 'w':
         case 'W':
         case 's':
@@ -362,9 +389,9 @@ void TextPrompt::open(const char* title, const char* text) {
 }
 
 void TextPrompt::layout(int width, int height, Font& font) {
-    const int dialogWidth = std::min(width - 16, 280);
+    const int dialogWidth = metrics::cardWidth(width, height, 16, 280, font.lineHeight());
     const int line = font.lineHeight();
-    const int buttonHeight = line + 12;
+    const int buttonHeight = metrics::buttonHeight(line, 12);
     const int dialogHeight = PADDING + line + PADDING / 2 + line + 8 + PADDING + buttonHeight + PADDING;
     // In the upper part of the screen, an on-screen keyboard may come later below it
     frame = { (width - dialogWidth) / 2, std::max(4, (height - dialogHeight) / 3), dialogWidth, dialogHeight };
@@ -376,11 +403,11 @@ void TextPrompt::layout(int width, int height, Font& font) {
 }
 
 void TextPrompt::draw(Canvas& canvas, Font& font, const UiTheme& theme) {
-    canvas.fillRect(0, 0, canvas.width, canvas.height, theme.scrim, 110);
-    canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, 8, theme.panel);
+    canvas.fillRect(0, 0, canvas.width, canvas.height, theme.scrim, metrics::SCRIM_ALPHA);
+    canvas.fillRoundRect(frame.x, frame.y, frame.width, frame.height, metrics::PANEL_RADIUS, theme.panel, theme.panelOpacity);
     font.drawText(canvas, frame.x + PADDING, frame.y + PADDING, heading, theme.text);
-    canvas.fillRoundRect(field.x, field.y, field.width, field.height, 4, theme.border);
-    canvas.fillRoundRect(field.x + 1, field.y + 1, field.width - 2, field.height - 2, 3, theme.panel);
+    canvas.fillRoundRect(field.x, field.y, field.width, field.height, metrics::FIELD_RADIUS, theme.border);
+    canvas.fillRoundRect(field.x + 1, field.y + 1, field.width - 2, field.height - 2, metrics::FIELD_RADIUS - 1, theme.panel);
     // The end of a long name stays in view, with the caret after it
     const char* shown = value;
     while (*shown != '\0' && font.textWidth(shown) > field.width - 12) {
diff --git a/Apps/Maps/main/Source/ui/Widgets.h b/Apps/Maps/main/Source/ui/Widgets.h
index f013dc5..396aff2 100644
--- a/Apps/Maps/main/Source/ui/Widgets.h
+++ b/Apps/Maps/main/Source/ui/Widgets.h
@@ -3,6 +3,7 @@
 
 #include "Canvas.h"
 
+#include <algorithm>
 #include <cstdint>
 
 namespace maps {
@@ -75,6 +76,11 @@ class ListView {
     /** Adds a row with a label and an optional detail on the right. Returns its index, -1 when full. */
     int add(const char* label, const char* detail = "");
     void setDetail(int index, const char* detail);
+    /**
+     * One sentence per row, in row order, shown above the hint while a row is highlighted (nothing for touch, which
+     * never highlights). The texts must outlive the list; the line is reserved in the layout whenever they are set.
+     */
+    void setDescriptions(const char* const* texts, int count);
     int count() const { return itemCount; }
     int selected() const { return selection; }
     /** Moves the selection without showing the highlight. */
@@ -106,10 +112,17 @@ class ListView {
     int rowAt(int x, int y) const;
     const Rect& bounds() const { return frame; }
     int rowHeight() const { return rowPixels; }
+    /** For tests: the rectangle of a visible row (the highlight's size), false when the row is not visible. */
+    bool rowRect(int index, Rect& rect) const;
+    /** For tests: the rows that show at once, and the header's back and select areas. */
+    int visibleRowCount() const { return std::min(visibleRows, itemCount); }
+    const Rect& backRect() const { return header.back; }
+    const Rect& selectRect() const { return header.select; }
 
 private:
     void keepVisible();
     int hintLines() const;
+    int descriptionHeight(Font& font) const;
 
     struct Item {
         char label[TEXT_LENGTH];
@@ -126,6 +139,8 @@ class ListView {
     char hint[TEXT_LENGTH * 2] = "";
     Rect frame {};
     HeaderLayout header {};
+    const char* const* descriptions = nullptr;
+    int descriptionCount = 0;
     int rowPixels = 24;
     int listTop = 0;
     bool fullScreen = true;
@@ -148,6 +163,11 @@ class Dialog {
     /** Returns Chosen when the confirm button is focused. */
     UiAction press();
 
+    /** For tests: the dialog, its buttons. */
+    const Rect& bounds() const { return frame; }
+    const Rect& confirmRect() const { return confirmButton; }
+    const Rect& cancelRect() const { return cancelButton; }
+
 private:
     bool visible = false;
     bool danger = false;
@@ -180,6 +200,12 @@ class TextPrompt {
     UiAction handleKey(uint32_t key);
     UiAction handleTap(int x, int y);
 
+    /** For tests: the dialog, its text field and buttons. */
+    const Rect& bounds() const { return frame; }
+    const Rect& fieldRect() const { return field; }
+    const Rect& okRect() const { return okButton; }
+    const Rect& cancelRect() const { return cancelButton; }
+
 private:
     void append(uint32_t codepoint);
     void erase();
diff --git a/Apps/Maps/manifest.properties b/Apps/Maps/manifest.properties
index 30a0ac1..08e66c0 100644
--- a/Apps/Maps/manifest.properties
+++ b/Apps/Maps/manifest.properties
@@ -2,8 +2,8 @@ manifest.version=0.3
 target.sdk=0.8.0-dev
 target.platforms=esp32s3,esp32p4
 id=tactility.maps
-version.name=0.8.0
-version.code=10
+version.name=0.8.1
+version.code=11
 app.0.id=tactility.maps
 app.0.name=Maps
 app.0.binary=maps