2cf5396467 · krz/moonrise

App/Sources/LaunchesScreen.swift +5 −2

         }
         .foregroundStyle(ink)
         .background(background.ignoresSafeArea())
-        .refreshable { if router.showNews { newsReload += 1 } else { await load() } }
+        .refreshable { if router.showNews { newsReload += 1 } else { await load(force: true) } }
         .task { await load() }
         .sheet(item: $selected) { LaunchDetail(launch: $0, ink: ink, accent: accent, background: background) }
     }
                 }
     }
-    private func load() async {
+    /// The backend polls every 10 minutes; a visit within 5 minutes of the last load reuses it.
+    private func load(force: Bool = false) async {
         guard let apiBase else { error = "No backend configured for this build."; return }
+        if !force, let cached: LaunchList = FeedMemo.get("launches", maxAge: 300) { list = cached; return }
         do {
             list = try await LaunchFeed.fetch(base: apiBase)
+            if let list { FeedMemo.set("launches", list) }
             error = nil
         } catch {
             self.error = "Couldn't load launches. Pull to retry."

App/Sources/LibraryScreen.swift +5 −17

         }
         // Constellations whose stars are on average more than 25° up two hours into the night.
         let when = t.start.addingTimeInterval(2 * 3600)
-        let byHR = Dictionary(uniqueKeysWithValues: Catalog.stars.map { ($0.hr, $0) })
         let scored: [(LibraryPage, Double)] = Catalog.constellations.compactMap { c in
             guard let page = Library.page(constellation: c.id) else { return nil }
-            let stars = Set(c.lines.joined()).compactMap { byHR[$0] }
+            let stars = Set(c.lines.joined()).compactMap { Catalog.starsByHR[$0] }
             guard !stars.isEmpty else { return nil }
             let alts = SkyEngine.horizontal(j2000: stars.map { $0.position(at: when) }, at: when, from: observer).map(\.altitude)
             return (page, alts.reduce(0, +) / Double(alts.count))
         ZStack {
             tile
             if let image = page.image {
-                AsyncImage(url: image.url) { phase in
+                // Library of Congress scans carry a frame and colour bars; crop to the plate.
-                    if case .success(let img) = phase {
+                RemoteImage(url: image.url, points: large ? 640 : 260) { fallback }
-                        // Library of Congress scans carry a frame and colour bars; crop to the plate.
+                    .scaleEffect(image.url.host() == "tile.loc.gov" ? 1.45 : 1)
-                        img.resizable().scaledToFill().scaleEffect(image.url.host() == "tile.loc.gov" ? 1.45 : 1)
-                    } else {
-                        fallback
-                    }
-                }
             } else {
                 fallback
             }
                 Color(white: 0.06)
                     .frame(height: 340)
                     .overlay {
-                        AsyncImage(url: image.url) { phase in
+                        RemoteImage(url: image.url, points: 900) { ProgressView().tint(ink) }
-                            switch phase {
-                            case .success(let img): img.resizable().scaledToFill()
-                            case .failure: Text("Image unavailable").font(.caption).dimmed(0.6)
-                            default: ProgressView().tint(ink)
-                            }
-                        }
                     }
                     .clipped()
                     .accessibilityLabel(image.caption)

App/Sources/MarsSection.swift +6 −4

             }
             Text("Local mean solar time. A Mars sol is 24 h 39 m 35 s. Raw images: NASA/JPL-Caltech.").font(.caption2).dimmed(0.5)
         }
-        .task { images = (try? await MarsImage.latest()) ?? [] }
+        .task {
+            // The rovers send a few batches a day; reuse a fetch from the last 30 minutes.
+            if let cached: [MarsImage] = FeedMemo.get("mars", maxAge: 1800) { images = cached; return }
+            if let fresh = try? await MarsImage.latest() { images = fresh; FeedMemo.set("mars", fresh) }
+        }
         .sheet(item: $shown) { MarsImageView(image: $0) }
     }
                 HStack(spacing: 6) {
                     ForEach(mine) { image in
                         Button { shown = image } label: {
-                            AsyncImage(url: image.thumbnail) { phase in
+                            RemoteImage(url: image.thumbnail, points: 130) { Color.white.opacity(0.06) }
-                                if case .success(let img) = phase { img.resizable().scaledToFill() } else { Color.white.opacity(0.06) }
-                            }
                             .frame(width: 88, height: 88)
                             .clipped()
                         }

App/Sources/MoonriseApp.swift +1

	@@ -36,6 +36,7 @@ struct MoonriseApp: App {
36		36
37	final class AppDelegate: NSObject, UIApplicationDelegate, UNUserNotificationCenterDelegate {	37	final class AppDelegate: NSObject, UIApplicationDelegate, UNUserNotificationCenterDelegate {
38	func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {	38	func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {
		39	ImageLoader.configureURLCache()
39	UNUserNotificationCenter.current().delegate = self	40	UNUserNotificationCenter.current().delegate = self
40	application.registerForRemoteNotifications()	41	application.registerForRemoteNotifications()
41	return true	42	return true

App/Sources/NewsList.swift +6 −5

                 ProgressView().tint(ink).padding(.top, 40).frame(maxWidth: .infinity)
             }
         }
-        .task(id: reload) { await load() }
+        .task(id: reload) { await load(force: reload > 0) }
     }
-    func load() async {
+    /// The API caches for 10 minutes; reuse a fetch from that window unless pulled to refresh.
+    func load(force: Bool) async {
+        if !force, let cached: [NewsArticle] = FeedMemo.get("news", maxAge: 600) { articles = cached; return }
         do {
             articles = try await NewsArticle.latest()
+            if let articles { FeedMemo.set("news", articles) }
             failed = false
         } catch {
             failed = articles == nil
             }
             Spacer(minLength: 0)
             if let image = a.image {
-                AsyncImage(url: image) { phase in
+                RemoteImage(url: image, points: 110) { ink.opacity(0.06) }
-                    if case .success(let img) = phase { img.resizable().scaledToFill() } else { ink.opacity(0.06) }
-                }
                 .frame(width: 72, height: 72)
                 .clipped()
                 .accessibilityHidden(true)

App/Sources/PageDrawing.swift +1 −2

	@@ -194,8 +194,7 @@ struct ConstellationFigure: View {
194		194
195	var body: some View {	195	var body: some View {
196	let lines = Catalog.constellations.first { $0.id == id }?.lines ?? []	196	let lines = Catalog.constellations.first { $0.id == id }?.lines ?? []
197	let byHR = Dictionary(uniqueKeysWithValues: Catalog.stars.map { ($0.hr, $0) })	197	let stars = Set(lines.joined()).compactMap { Catalog.starsByHR[$0] }
198	let stars = Set(lines.joined()).compactMap { byHR[$0] }
199	Canvas { context, size in	198	Canvas { context, size in
200	guard !stars.isEmpty else { return }	199	guard !stars.isEmpty else { return }
201	// Gnomonic projection about the figure's centre.	200	// Gnomonic projection about the figure's centre.

App/Sources/RemoteImage.swift added +88

@@ -0,0 +1,88 @@
	1	import ImageIO
	2	import SwiftUI
	3	import UIKit
	4
	5	/// Images from the network, decoded at the size they are shown rather than full size, and kept in memory.
	6	/// Downloads go through URLSession.shared, so the disk cache set up in `configureURLCache` applies.
	7	enum ImageLoader {
	8	// NSCache is thread-safe.
	9	nonisolated(unsafe) private static let cache: NSCache<NSString, UIImage> = {
	10	let c = NSCache<NSString, UIImage>()
	11	c.totalCostLimit = 60 * 1024 * 1024
	12	return c
	13	}()
	14
	15	static func cached(_ url: URL, maxPixels: Int) -> UIImage? {
	16	cache.object(forKey: key(url, maxPixels))
	17	}
	18
	19	static func load(_ url: URL, maxPixels: Int) async throws -> UIImage {
	20	if let hit = cached(url, maxPixels: maxPixels) { return hit }
	21	let (data, _) = try await URLSession.shared.data(from: url)
	22	let image = try await Task.detached(priority: .userInitiated) { try downsample(data, maxPixels: maxPixels) }.value
	23	let cost = Int(image.size.width * image.size.height * image.scale * image.scale * 4)
	24	cache.setObject(image, forKey: key(url, maxPixels), cost: cost)
	25	return image
	26	}
	27
	28	private static func key(_ url: URL, _ maxPixels: Int) -> NSString { "\(maxPixels)\|\(url.absoluteString)" as NSString }
	29
	30	/// Decodes straight to a thumbnail no larger than `maxPixels` on its long side.
	31	nonisolated static func downsample(_ data: Data, maxPixels: Int) throws -> UIImage {
	32	guard let source = CGImageSourceCreateWithData(data as CFData, [kCGImageSourceShouldCache: false] as CFDictionary),
	33	let cg = CGImageSourceCreateThumbnailAtIndex(source, 0, [
	34	kCGImageSourceCreateThumbnailFromImageAlways: true,
	35	kCGImageSourceCreateThumbnailWithTransform: true,
	36	kCGImageSourceShouldCacheImmediately: true,
	37	kCGImageSourceThumbnailMaxPixelSize: maxPixels,
	38	] as CFDictionary)
	39	else { throw URLError(.cannotDecodeContentData) }
	40	return UIImage(cgImage: cg)
	41	}
	42
	43	/// A bigger shared cache than the default (512 KB memory, about 20 MB disk), so Library photos and
	44	/// feed responses survive between visits. Responses over 5% of the disk size are never stored.
	45	static func configureURLCache() {
	46	URLCache.shared = URLCache(memoryCapacity: 24 * 1024 * 1024, diskCapacity: 400 * 1024 * 1024)
	47	}
	48	}
	49
	50	/// A remote image decoded for `points` (the longer side it is drawn at), with a placeholder while loading.
	51	struct RemoteImage<Placeholder: View>: View {
	52	var url: URL?
	53	var points: CGFloat
	54	var contentMode: ContentMode = .fill
	55	@ViewBuilder var placeholder: () -> Placeholder
	56	@Environment(\.displayScale) private var scale
	57	@State private var image: UIImage?
	58
	59	private var maxPixels: Int { Int(points * scale) }
	60
	61	var body: some View {
	62	Group {
	63	if let image = image ?? url.flatMap({ ImageLoader.cached($0, maxPixels: maxPixels) }) {
	64	Image(uiImage: image).resizable().aspectRatio(contentMode: contentMode)
	65	} else {
	66	placeholder()
	67	}
	68	}
	69	.task(id: url) {
	70	guard let url, image == nil else { return }
	71	image = try? await ImageLoader.load(url, maxPixels: maxPixels)
	72	}
	73	}
	74	}
	75
	76	/// Recent feed results kept in memory, so switching tabs or views doesn't refetch them.
	77	/// Pull to refresh bypasses it.
	78	@MainActor
	79	enum FeedMemo {
	80	private static var store: [String: (at: Date, value: Any)] = [:]
	81
	82	static func get<T>(_ key: String, maxAge: TimeInterval) -> T? {
	83	guard let hit = store[key], Date.now.timeIntervalSince(hit.at) < maxAge else { return nil }
	84	return hit.value as? T
	85	}
	86
	87	static func set(_ key: String, _ value: Any) { store[key] = (.now, value) }
	88	}

App/Sources/SkyModel.swift +8

     private(set) var passes: [SatellitePass] = []
     private var elements: [OrbitalElements] = []
     private var elementsFetched: Date?
+    private var passesComputed: (at: Date, observer: Observer, elementsFetched: Date?)?
     private var weatherFetched: Date?
     /// Hours from now shown by the time scrubber.
     var offsetHours = 0.0 { didSet { refresh() } }
                 elementsFetched = .now
             }
         }
+        // Reuse the last result for an hour unless the place or the orbits changed (about 1 s of work for 158 objects).
+        if let last = passesComputed, last.observer == observer, last.elementsFetched == elementsFetched,
+           Date.now.timeIntervalSince(last.at) < 3600 {
+            passes.removeAll { $0.set < .now }
+            return
+        }
         let elements = elements, observer = observer
         passes = await Task.detached {
             elements.flatMap { SkyEngine.passes(of: $0, from: .now, hours: 72, observer: observer) }.sorted { $0.rise < $1.rise }
         }.value
+        passesComputed = (.now, observer, elementsFetched)
     }
     /// SWPC asks for no more than once a minute; this checks every 10.

App/Sources/SolarSystem3D.swift +21 −10

         e.camera.camera.fieldOfViewInDegrees = SolarCamera.fovDegrees
         e.root.addChild(e.camera)
-        var sunMaterial = UnlitMaterial(color: UIColor(red: 1, green: 0.86, blue: 0.5, alpha: 1))
+        let sunMaterial = UnlitMaterial(color: UIColor(red: 1, green: 0.86, blue: 0.5, alpha: 1))
-        if let url = Bundle.main.url(forResource: "sun", withExtension: "jpg", subdirectory: "Globes"), let t = try? TextureResource.load(contentsOf: url) {
-            sunMaterial.color = .init(tint: .white, texture: .init(t))
-        }
         e.sun.model = ModelComponent(mesh: .generateSphere(radius: 1), materials: [sunMaterial])
         e.root.addChild(e.sun)
         // Glow: nested translucent shells, fainter outward.
         spheres += SolarMoon.all.map { ($0.id, $0.color, 0) }
         for s in spheres {
             let body = ModelEntity()
-            var m = UnlitMaterial()
+            // Plain colour first; the map, if there is one, is swapped in once it has loaded.
-            if let url = GlobeView.mapURL(s.id), let texture = try? TextureResource.load(contentsOf: url) {
+            let m = UnlitMaterial(color: UIColor(Color(hex: s.color) ?? .gray))
-                m.color = .init(texture: .init(texture))
-            } else {
-                m.color = .init(tint: UIColor(Color(hex: s.color) ?? .gray))
-            }
             body.model = ModelComponent(mesh: .generateSphere(radius: 1), materials: [m])
             body.orientation = simd_quatf(angle: Float(s.tilt * .pi / 180), axis: [1, 0, 0])
             if s.id == "saturn" { body.addChild(Self.annulus(inner: 1.24, outer: 2.27, color: UIColor(red: 0.85, green: 0.78, blue: 0.62, alpha: 0.7))) }
         }
         e.bodies["earth"]?.addChild(e.aurora)
         place()
+        loadTextures()
+    }
+    /// Loads surface maps off the main thread (about 0.6 s for all of them) and applies each as it arrives.
+    private func loadTextures() {
+        let e = entities
+        var jobs: [(entity: ModelEntity, url: URL, tint: UIColor)] = e.bodies.compactMap { id, entity in
+            GlobeView.mapURL(id).map { (entity, $0, .white) }
+        }
+        if let sun = Bundle.main.url(forResource: "sun", withExtension: "jpg", subdirectory: "Globes") { jobs.append((e.sun, sun, .white)) }
+        for job in jobs {
+            Task {
+                guard let texture = try? await TextureResource(contentsOf: job.url) else { return }
+                var m = UnlitMaterial()
+                m.color = .init(tint: job.tint, texture: .init(texture))
+                job.entity.model?.materials = [m]
+            }
+        }
     }
     /// Moves everything for the current date, scale, layers and camera.

App/Sources/SunScreen.swift +9 −3

         }
         .foregroundStyle(ink)
         .background(background.ignoresSafeArea())
-        .refreshable { await load() }
+        .refreshable { await load(force: true) }
-        .task { await load() }
+        .task { await load(force: false) }
     }
-    private func load() async {
+    /// NOAA updates these every minute or so; a visit within 5 minutes of the last load reuses it.
+    private func load(force: Bool) async {
+        if !force, let cached: ([KpBar], [XRaySample], Ovation?) = FeedMemo.get("sun", maxAge: 300) {
+            (kp, xray, ovation) = cached
+            return
+        }
         imageID = .now
         async let k = try? SpaceWeather.fetchKpBars()
         async let x = try? XRay.fetch()
         xray = xrayResult ?? xray
         ovation = ovationResult ?? ovation
         failed = kpResult == nil || xrayResult == nil || ovationResult == nil
+        if !failed { FeedMemo.set("sun", (kp, xray, ovation)) }
     }
     private var image: some View {

Packages/MoonriseKit/Sources/Library/Library.swift +32 −5

	@@ -137,15 +137,38 @@ public enum Library {
137		137
138	/// Case- and diacritic-insensitive match on title and subtitle first, then facts and essay.	138	/// Case- and diacritic-insensitive match on title and subtitle first, then facts and essay.
139	public static func search(_ query: String) -> [LibraryPage] {	139	public static func search(_ query: String) -> [LibraryPage] {
140	let q = query.trimmingCharacters(in: .whitespaces)	140	let q = fold(query.trimmingCharacters(in: .whitespaces))
141	guard !q.isEmpty else { return [] }	141	guard !q.isEmpty else { return [] }
142	let opts: String.CompareOptions = [.caseInsensitive, .diacriticInsensitive]	142	var strong: [LibraryPage] = [], weak: [LibraryPage] = []
143	let strong = pages.filter { $0.title.range(of: q, options: opts) != nil \|\| $0.subtitle.range(of: q, options: opts) != nil \|\| $0.id == q.lowercased() }	143	for entry in searchIndex {
144	let weak = pages.filter { p in	144	if entry.head.contains(q) \|\| entry.page.id == q { strong.append(entry.page) } else if entry.body.contains(q) { weak.append(entry.page) }
145	!strong.contains(p) && (p.essay.range(of: q, options: opts) != nil \|\| p.facts.contains { $0.value.range(of: q, options: opts) != nil })
146	}	145	}
147	return strong + weak	146	return strong + weak
148	}	147	}
		148
		149	/// Lowercased, diacritic-free text per page, built once: title and subtitle, then essay and facts.
		150	private static let searchIndex: [(page: LibraryPage, head: String, body: String)] = pages.map { p in
		151	(p, fold(p.title + "\n" + p.subtitle), fold(p.essay + "\n" + p.facts.map(\.value).joined(separator: "\n")))
		152	}
		153
		154	static func fold(_ s: String) -> String {
		155	s.folding(options: [.caseInsensitive, .diacriticInsensitive], locale: nil)
		156	}
		157
		158	private static let relatedLock = NSLock()
		159	nonisolated(unsafe) private static var relatedCache: [String: [LibraryPage]] = [:]
		160
		161	/// `page.related()` computed once per page.
		162	static func cachedRelated(_ page: LibraryPage, compute: () -> [LibraryPage]) -> [LibraryPage] {
		163	relatedLock.lock()
		164	if let hit = relatedCache[page.id] { relatedLock.unlock(); return hit }
		165	relatedLock.unlock()
		166	let value = compute()
		167	relatedLock.lock()
		168	relatedCache[page.id] = value
		169	relatedLock.unlock()
		170	return value
		171	}
149	}	172	}
150		173
151	extension LibraryPage {	174	extension LibraryPage {
	@@ -153,6 +176,10 @@ extension LibraryPage {
153	/// A title also matches by its part before a dash or bracket ("Cassini" for "Cassini–Huygens").	176	/// A title also matches by its part before a dash or bracket ("Cassini" for "Cassini–Huygens").
154	/// Titles shorter than five characters ("Sun", "Moon", "Io") only count when they are mentioned here.	177	/// Titles shorter than five characters ("Sun", "Moon", "Io") only count when they are mentioned here.
155	public func related(limit: Int = 10) -> [LibraryPage] {	178	public func related(limit: Int = 10) -> [LibraryPage] {
		179	Library.cachedRelated(self) { uncachedRelated(limit: limit) }
		180	}
		181
		182	private func uncachedRelated(limit: Int) -> [LibraryPage] {
156	func mentions(_ text: String, _ title: String) -> Bool {	183	func mentions(_ text: String, _ title: String) -> Bool {
157	var search = text.startIndex..<text.endIndex	184	var search = text.startIndex..<text.endIndex
158	while let r = text.range(of: title, range: search) {	185	while let r = text.range(of: title, range: search) {

Packages/MoonriseKit/Sources/SkyRenderer/SkyScene.swift +3

	@@ -52,6 +52,9 @@ public enum Catalog {
52	return rows.map { Star(hr: Int($0[0]), ra: $0[1], dec: $0[2], magnitude: $0[3], colorIndex: $0[4], pmRA: $0[5], pmDec: $0[6]) }	52	return rows.map { Star(hr: Int($0[0]), ra: $0[1], dec: $0[2], magnitude: $0[3], colorIndex: $0[4], pmRA: $0[5], pmDec: $0[6]) }
53	}()	53	}()
54		54
		55	/// Stars by HR number.
		56	public static let starsByHR: [Int: Star] = Dictionary(uniqueKeysWithValues: stars.map { ($0.hr, $0) })
		57
55	/// Built by scripts/make-skycultures.py.	58	/// Built by scripts/make-skycultures.py.
56	public static let skyCultures: [SkyCulture] = {	59	public static let skyCultures: [SkyCulture] = {
57	let url = Bundle.module.url(forResource: "skycultures", withExtension: "json")!	60	let url = Bundle.module.url(forResource: "skycultures", withExtension: "json")!

server/src/index.ts +11 −7

 const LAUNCH_CRON = "*/10 * * * *";
 const SATELLITE_CRON = "7 */2 * * *";
-const json = (body: unknown, status = 200) => Response.json(body, { status });
+const json = (body: unknown, status = 200, maxAge?: number) =>
+  Response.json(body, { status, headers: maxAge && status === 200 ? { "cache-control": `public, max-age=${maxAge}` } : {} });
+/** How long clients may reuse each GET response, matched to how often its source is polled. */
+export const MAX_AGE = { today: 60, launches: 300, satellites: 3600, live: 300 } as const;
 function validDevice(d: Partial<DeviceRequest>): d is DeviceRequest {
   return (
 async function today(env: Env, now: Date): Promise<Response> {
   const row = await env.DB.prepare("SELECT fetched_at, body FROM feed_snapshots WHERE feed = 'swpc' AND ok = 1").first<{ fetched_at: string; body: string }>();
-  if (!row) return json({ spaceWeather: null });
+  if (!row) return json({ spaceWeather: null }, 200, MAX_AGE.today);
   const w = JSON.parse(row.body) as SpaceWeather;
   w.forecast = w.forecast.map((f) => ({ ...f, start: new Date(f.start) }));
   return json({
     spaceWeather: { kpNow: w.kpNow, observedAt: w.observedAt, kpNext24h: next24h(w, now), fetchedAt: row.fetched_at },
-  });
+  }, 200, MAX_AGE.today);
 }
 export default {
     if (request.method === "GET" && url.pathname === "/v1/live") return live(env, url, now);
     if (request.method === "GET" && url.pathname === "/v1/satellites") {
       const row = await env.DB.prepare("SELECT fetched_at, body FROM feed_snapshots WHERE feed = 'celestrak' AND ok = 1").first<{ fetched_at: string; body: string }>();
-      return json({ fetchedAt: row?.fetched_at ?? null, satellites: row ? JSON.parse(row.body) : [] });
+      return json({ fetchedAt: row?.fetched_at ?? null, satellites: row ? JSON.parse(row.body) : [] }, 200, MAX_AGE.satellites);
     }
     if (request.method === "POST" && url.pathname === "/v1/devices") {
   const at = atParam ? new Date(atParam) : now;
   if (Number.isNaN(at.getTime())) return json({ error: "invalid at" }, 400);
   const event = activeEvent(at);
-  if (!event) return json({ event: null });
+  if (!event) return json({ event: null }, 200, MAX_AGE.live);
   const key = `live:${event.id}`;
   const row = await env.DB.prepare("SELECT fetched_at, body FROM feed_snapshots WHERE feed = ?1 AND ok = 1").bind(key).first<{ fetched_at: string; body: string }>();
       console.error("horizons", String(e));
     }
   }
-  return json({ event, at: at.toISOString(), points: points.filter((p) => p[0] * 1000 <= at.getTime()) });
+  return json({ event, at: at.toISOString(), points: points.filter((p) => p[0] * 1000 <= at.getTime()) }, 200, MAX_AGE.live);
 }
 async function launches(env: Env, now: Date): Promise<Response> {
       mission: r.mission, missionType: r.mission_type, missionDescription: r.mission_description, orbit: r.orbit,
       pad: r.pad, location: r.location, padLatitude: r.pad_latitude, padLongitude: r.pad_longitude,
     })),
-  });
+  }, 200, MAX_AGE.launches);
 }
 // Failures are recorded under "<feed>:error" so the last good snapshot and its time survive.

Commit 2cf5396467

Commit `2cf5396467`