Refresh the Flutter snapshot: v3 tickets V3-04 through V3-16, plus a fresh installable APK

V3-04 through V3-07, V3-10, V3-16 shipped complete; V3-11/V3-12/V3-14 shipped code-complete pending device/account verification; V3-08/V3-09 deferred behind a new V3-17 (self-hosted OSRM investigation). 316 tests passing, up from 221.

The APK is a fresh release build (debug-signed, no release signing config exists yet) with two build fixes applied: core library desugaring enabled for flutter_local_notifications, and sentry_flutter bumped to 9.27.0 (8.14.2's bundled Kotlin plugin was incompatible with this project's Kotlin 2.4.0 toolchain).

rippr-flutter-src/test/tile_cache_test.dart

@@ -0,0 +1,92 @@
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:rippr/src/tiles/tile_cache.dart';
+import 'package:rippr/src/tiles/tile_math.dart';
+
+void main() {
+  late Directory tempDir;
+  late FileTileCache cache;
+
+  setUp(() async {
+    tempDir = await Directory.systemTemp.createTemp('rippr_tile_cache_test_');
+  });
+
+  tearDown(() async {
+    if (tempDir.existsSync()) tempDir.deleteSync(recursive: true);
+  });
+
+  Uint8List bytesOfSize(int n) => Uint8List.fromList(List.filled(n, 1));
+
+  test('a stored tile round-trips', () async {
+    cache = FileTileCache(directory: tempDir, maxBytes: 1024 * 1024);
+    const key = TileKey(12, 100, 200);
+
+    await cache.put(key, bytesOfSize(50));
+    final read = await cache.get(key);
+
+    expect(read, isNotNull);
+    expect(read!.length, 50);
+  });
+
+  test('a tile never written is a miss, not an error', () async {
+    cache = FileTileCache(directory: tempDir, maxBytes: 1024 * 1024);
+    expect(await cache.get(const TileKey(1, 1, 1)), isNull);
+  });
+
+  test('sizeBytes reflects everything stored', () async {
+    cache = FileTileCache(directory: tempDir, maxBytes: 1024 * 1024);
+    await cache.put(const TileKey(1, 0, 0), bytesOfSize(100));
+    await cache.put(const TileKey(1, 0, 1), bytesOfSize(200));
+
+    expect(await cache.sizeBytes(), 300);
+  });
+
+  test('eviction at the cap removes the least-recently-used tile first', () async {
+    // Room for two 100-byte tiles at a time.
+    cache = FileTileCache(directory: tempDir, maxBytes: 200);
+    const a = TileKey(1, 0, 0);
+    const b = TileKey(1, 0, 1);
+    const c = TileKey(1, 0, 2);
+
+    await cache.put(a, bytesOfSize(100));
+    await cache.put(b, bytesOfSize(100));
+    // Touch `a` so `b` becomes the least-recently-used.
+    await cache.get(a);
+    await cache.put(c, bytesOfSize(100));
+
+    expect(await cache.get(a), isNotNull, reason: 'recently touched, must survive');
+    expect(await cache.get(b), isNull, reason: 'least-recently-used, must be evicted');
+    expect(await cache.get(c), isNotNull, reason: 'just written, must survive');
+    expect(await cache.sizeBytes(), lessThanOrEqualTo(200));
+  });
+
+  test('the cache never exceeds its cap after many writes', () async {
+    cache = FileTileCache(directory: tempDir, maxBytes: 500);
+    for (var i = 0; i < 20; i++) {
+      await cache.put(TileKey(1, i, 0), bytesOfSize(100));
+    }
+    expect(await cache.sizeBytes(), lessThanOrEqualTo(500));
+  });
+
+  test('clear removes every tile and resets size to zero', () async {
+    cache = FileTileCache(directory: tempDir, maxBytes: 1024 * 1024);
+    await cache.put(const TileKey(1, 0, 0), bytesOfSize(100));
+    await cache.put(const TileKey(1, 0, 1), bytesOfSize(100));
+
+    await cache.clear();
+
+    expect(await cache.sizeBytes(), 0);
+    expect(await cache.get(const TileKey(1, 0, 0)), isNull);
+  });
+
+  test('a cache re-opened over the same directory sees what was stored', () async {
+    cache = FileTileCache(directory: tempDir, maxBytes: 1024 * 1024);
+    await cache.put(const TileKey(5, 10, 10), bytesOfSize(64));
+
+    final reopened = FileTileCache(directory: tempDir, maxBytes: 1024 * 1024);
+    expect(await reopened.get(const TileKey(5, 10, 10)), isNotNull);
+    expect(await reopened.sizeBytes(), 64);
+  });
+}