diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6e6ab1f6..5896cccb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -105,6 +105,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   unchanged, and an older shell (or a multi-file recording) falls back to
   the previous exporter automatically. Requires a LapWing build with the
   `video_export_*` pipeline (plan 0024).
+- **Drag mode** — drop in a log from a drag strip (or any venue the app doesn't
+  know) and standing-start runs are detected automatically: pick 1/8 mile,
+  1000 ft or 1/4 mile and every pass gets a time-slip style breakdown — ET at
+  the scoring distance plus 60 ft / 330 ft / 660 ft / 1000 ft splits. Passes
+  that lifted early stay listed as incomplete with the splits they did reach,
+  and your chosen distance is remembered per file and switchable from the
+  session header. (Plan 0022.)
 
 ### Changed
 - **New LapWing look.** The app now wears the LapWing brand from the
@@ -116,9 +123,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **The footer now links to PerchWerks.** "LapWing is a PerchWerks product",
   with the shared bird mark, takes you to perchwerks.com (it replaces the old
   "Operated by PerchWerks LLC" line).
-- **The shared-session "read-only" banner text is readable again** — it was
-  drawn in a colour meant for text on a solid amber fill, so it nearly
-  vanished against the banner's pale tint.
 - **The app no longer loses its whole offline cache to a flaky connection.**
   Caching the app was previously one ~10 MB all-or-nothing download: if anything
   failed partway through — losing signal at a track, say — *nothing* was cached
@@ -149,16 +153,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   burn-in export will call this same renderer, so all three outputs match by
   construction.
 
-### Added
-- **Drag mode** — drop in a log from a drag strip (or any venue the app doesn't
-  know) and standing-start runs are detected automatically: pick 1/8 mile,
-  1000 ft or 1/4 mile and every pass gets a time-slip style breakdown — ET at
-  the scoring distance plus 60 ft / 330 ft / 660 ft / 1000 ft splits. Passes
-  that lifted early stay listed as incomplete with the splits they did reach,
-  and your chosen distance is remembered per file and switchable from the
-  session header.
-
 ### Fixed
+- **The shared-session "read-only" banner text is readable again** — it was
+  drawn in a colour meant for text on a solid amber fill, so it nearly
+  vanished against the banner's pale tint.
+- **Setup history no longer hangs on "Loading…" or fails silently.** If the
+  history can't be read, the panel now says so with a Retry button, and a
+  rollback or duplicate that fails shows an error instead of doing nothing.
+  (Plan 0028.)
+- **One damaged telemetry packet no longer rejects a whole GoPro import.** A
+  malformed GPS payload is skipped (a one-second gap) and the rest of the
+  recording imports. A corrupt or hostile MP4 whose sample table claims
+  billions of entries is also capped instead of freezing the tab. (Plan 0029.)
+- **Insta360 (Android app): switching recordings quickly could stop the new
+  stream.** A previous recording's player closing late no longer shuts down
+  the one you just opened. (Plan 0025.)
 - **The Insta360 import dialog no longer spins forever when reopened.** In the
   Android app, reopening the camera dialog while a camera was still connected
   got stuck on its loading spinner, and only unloading the video got you out.
diff --git a/CLAUDE.md b/CLAUDE.md
index 25d2af35..e0c66b42 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -95,7 +95,7 @@ src/
 │   ├── graphview/         # Pro mode: GraphPanel, GraphViewPanel, MiniMap, SingleSeriesChart, GGDiagram, InfoBox, PanelCard (resizable card chrome for relocated Video/Mini-Map panels). The left column collapses via a divider flag tab (any screen size), and Video/Mini-Map can be relocated into the resizable graph stack from the top of the "Add Graph" picker (GraphPanel reports which are active so the host drops its duplicate VideoPlayer — single shared video ref). Split graphs (tablet+): SecondaryGraphStack mirrors the main panel's graph set for a chosen overlay lap in a draggable two-up view, overriding PlaybackContext for its subtree (nested PlaybackProvider) so one cursor lands on the same track position in both laps (distance-mapped via lib/referenceUtils mapIndexByDistance); SecondaryVideo is a literal second, lap-synced <video> for in-session overlay laps.
 │   ├── drawer/            # File-manager drawer tabs (Files, Vehicles/Karts, Device*); SetupsTab + NotesTab also here but mounted as main-view tabs
 │   ├── track-editor/      # Track editor: VisualEditor, SectorListEditor, CourseSectorEditor, Add*Dialog
-│   ├── video-overlays/    # Video-export overlay system: registry + themes + per-widget *Overlay
+│   ├── video-overlays/    # Video-overlay system: registry + themes + settings/export UI + OverlayCanvas; ONE scene renderer (lib/overlayCanvasRenderer, plan 0023) draws every widget for preview, web export and native export alike
 │   ├── RaceLineView.tsx   # Leaflet map: race line, speed heatmap, braking zones
 │   ├── TelemetryChart.tsx # Canvas speed/telemetry chart (simple mode)
 │   ├── VideoPlayer.tsx    # Synced video playback + overlay system (multi-chunk GoPro playlists via lib/videoPlaylist); native: a camera stream renders as an <img> over lib/insta360's NativePlayerElement (plan 0025), with components/insta360/ (import dialog, 360° drag-to-point layer)
@@ -111,7 +111,7 @@ src/
 │   ├── datalogParser.ts   # ★ Format auto-detection router (entry point for all parsing)
 │   ├── gpsQualityFilter.ts # ★ Post-parse cleanup (plan 0014): rebuilds samples dropping provably-bad rows (negative sats/accuracy/DOP, DOP>10, or a position jump implying >MAX_SPEED_MPS) — all formats; quality values are never fabricated onto rows (see xrk/xrkResample)
 │   ├── *Parser.ts         # nmea, ubx, iracing (.ibt), vbo, dove, dovex, alfano, aim, motec
-│   ├── gopro/             # ★ GoPro video import (plan 0029): mp4Boxes (ranged-read ISO-BMFF → `gpmd` sample table), gpmf (KLV + GPS5/GPS9), goproTelemetry (pure → Dove CSV + known video sync offset), goproImport (File glue; async like XRK), videoHandoff (one-shot video → useVideoSync)
+│   ├── gopro/             # ★ GoPro video import (plan 0029): mp4Boxes (ranged-read ISO-BMFF → `gpmd` sample table), gpmf (KLV + GPS5/GPS9), goproTelemetry (pure → Dove CSV + known video sync offset), goproImport (File glue; async like XRK — dynamic-imported, off the main chunk), goproDetect (the cheap eager name/`ftyp` gates), videoHandoff (one-shot video → useVideoSync)
 │   ├── xrk/               # ★ AiM .xrk/.xrz importer — libxrk (Rust→WASM) in a Web Worker (→ docs/subsystems.md)
 │   ├── channels.ts        # ★ Canonical channel registry + normalizeChannels()
 │   ├── courseDetection.ts # ★ Auto track/course/direction detection + waypoint mode (→ docs/subsystems.md)
@@ -422,7 +422,7 @@ and the seeder: **→ `docs/i18n.md`**.
 outside preview/iframe contexts); `public/sw.js` is a legacy kill-switch. **The
 precache install is all-or-nothing — one failed request discards the whole
 service worker — so keep it small: heavy public assets belong in
-`DEFERRED_ASSET_DIRS` (runtime-cached + warmed after activation), never in the
+`DEFERRED_ASSET_DIRS` (`scripts/deferredAssets.ts`; runtime-cached + warmed after activation), never in the
 install-blocking glob. See plan 0027 before adding anything bulky to `public/`.** `vite.config.ts`
 also emits `/version.json` per build (the freshness signal for `versionCheck.ts`); it's
 excluded from the Workbox precache (`globIgnores`) and fetched uncached. Static
@@ -522,7 +522,8 @@ menu still opens instantly; `CourseSectorEditor` (carries
   (`lapwing-light` → `:root`, `lapwing-dark` → `.dark`); change colours there
   first, then mirror them here. Logos: `BrandLogo` (inline bird mark,
   `currentColor`) and `BrandLockup` (raster LAPWING lockup in `public/brand/` —
-  the logotype has no vector master yet). Archivo is display-only (`font-brand`).
+  the logotype has no vector master yet). Archivo is display-only (`font-brand`)
+  and only its italic face ships.
 - **Admin/cloud code** is fully optional and env-gated — the core app has zero
   admin/cloud dependencies on the eager graph.
 - **Edge functions** live in `supabase/functions/`, auto-deployed, configured in
diff --git a/README.md b/README.md
index 1c2286df..e3d16bc1 100644
--- a/README.md
+++ b/README.md
@@ -93,7 +93,7 @@ All formats are auto-detected on import:
 | MoTeC CSV | MoTeC i2 Pro export | `.csv` |
 | MoTeC LD | MoTeC native binary | `.ld` |
 | NMEA | Standard GPS sentences | `.nmea`, `.txt`, `.csv` |
-| GoPro video | GPS-tagged GoPro footage (HERO5+, GPS on) — the embedded GPMF telemetry track | `.mp4`, `.mov`, `.360` |
+| GoPro video | GPS-tagged GoPro footage (HERO5+, GPS on) — the embedded GPMF telemetry track | `.mp4`, `.mov` (`.360` experimental) |
 
 > **AiM XRK/XRZ** is parsed by [libxrk](https://github.com/m3rlin45/libxrk)'s
 > pure-Rust core **compiled to a small (~200 KB) WebAssembly module** — no
@@ -109,7 +109,9 @@ All formats are auto-detected on import:
 > saved as an ordinary Dove log, and because telemetry and footage share the
 > camera's clock the video opens alongside the session **already synced**.
 > Select all chapters of a split recording together to import them as one
-> session. Design notes: `docs/plans/0029-gopro-gps-video-import.md`.
+> session. **`.360` (MAX/Fusion) is experimental:** it carries the same
+> telemetry track and is accepted, but hasn't been tested against a real file
+> yet. Design notes: `docs/plans/0029-gopro-gps-video-import.md`.
 
 > **iRacing IBT** is the sim's only native on-disk telemetry export — the binary
 > `.ibt` file iRacing writes (at the session tick rate, typically 60 Hz) once
diff --git a/docs/plans/0022-drag-mode.md b/docs/plans/0022-drag-mode.md
index c3f190ce..81a3e4c7 100644
--- a/docs/plans/0022-drag-mode.md
+++ b/docs/plans/0022-drag-mode.md
@@ -1,7 +1,8 @@
 # Drag Mode — standing-start runs at unknown venues
 
-> Status: **IN PROGRESS** — detector landed first (logic-first, like plan 0015);
-> orchestration and UI follow in separate commits on this plan.
+> Status: **DONE** — all four commits below landed (detector first,
+> logic-first like plan 0015, then mapping, orchestration and UI); ships in
+> 4.2.0. The follow-ups section is deliberately out of scope for v1.
 
 ## Why this exists
 
diff --git a/docs/plans/0027-precache-resilience.md b/docs/plans/0027-precache-resilience.md
index 2b27838c..e0e82e16 100644
--- a/docs/plans/0027-precache-resilience.md
+++ b/docs/plans/0027-precache-resilience.md
@@ -50,8 +50,10 @@ service worker at all.
 
 ### Keep install small; defer the heavy extras
 
-`DEFERRED_ASSET_DIRS` in `vite.config.ts` (`samples/`, `loggers/`) is the single
-source of truth. It feeds three things:
+`DEFERRED_ASSET_DIRS` (`samples/`, `loggers/`) is the single source of truth —
+it lives in `scripts/deferredAssets.ts` (moved out of `vite.config.ts` after the
+4.2.0 release review so the runtime-cache route, previously a hand-copied regex,
+could be derived from it and unit-tested). It feeds three things:
 
 1. `globIgnores` — those directories stay out of the install-blocking precache.
 2. A `CacheFirst` runtime-caching route (`app-deferred-assets`), so once present
diff --git a/docs/plans/0029-gopro-gps-video-import.md b/docs/plans/0029-gopro-gps-video-import.md
index 8dd2eb46..ecf243dc 100644
--- a/docs/plans/0029-gopro-gps-video-import.md
+++ b/docs/plans/0029-gopro-gps-video-import.md
@@ -85,8 +85,14 @@ the C library).
 - `src/lib/gopro/gpmf.ts` — pure KLV decoder + GPS5/GPS9 stream extraction.
 - `src/lib/gopro/goproTelemetry.ts` — pure: payloads + timing → GPS rows →
   Dove CSV text, plus the sync offset.
-- `src/lib/gopro/goproImport.ts` — File glue (`isGoProVideoFile`,
-  `extractGoProTelemetry`, `importGoProVideo`).
+- `src/lib/gopro/goproImport.ts` — File glue (`extractGoProTelemetry`,
+  `importGoProVideo`). Dynamic-imported by `datalogParser`/`FileImport`, so the
+  extractor stays off the main chunk.
+- `src/lib/gopro/goproDetect.ts` — the cheap eager gates (`isGoProVideoFile`,
+  `isGoProVideoBuffer`) the routers call on every import.
+- Hardening (4.2.0 review): a malformed GPS stream skips its payload instead of
+  aborting the import, and a uniform `stsz` count is capped at
+  `fileSize / sampleSize` so a hostile MP4 can't allocate billions of entries.
 - `src/lib/gopro/videoHandoff.ts` — one-shot pending video for a session.
 - `src/components/FileImport.tsx`, `src/lib/datalogParser.ts`,
   `src/hooks/useVideoSync.ts` — wiring.
diff --git a/scripts/deferredAssets.test.ts b/scripts/deferredAssets.test.ts
new file mode 100644
index 00000000..d8dbb826
--- /dev/null
+++ b/scripts/deferredAssets.test.ts
@@ -0,0 +1,42 @@
+import { describe, it, expect } from "vitest";
+import { DEFERRED_ASSET_DIRS, deferredAssetPathPattern, sameOriginPathMatcher } from "./deferredAssets";
+
+const at = (path: string) => new URL(path, "https://lapwingdata.com");
+
+describe("deferredAssetPathPattern", () => {
+  it("derives the route test from the directory list", () => {
+    const re = deferredAssetPathPattern(DEFERRED_ASSET_DIRS);
+    expect(re.source).toBe("^\\/(?:samples|loggers)\\/");
+    for (const dir of DEFERRED_ASSET_DIRS) expect(re.test(`/${dir}/file.bin`)).toBe(true);
+  });
+
+  it("matches only whole top-level directories", () => {
+    const re = deferredAssetPathPattern(DEFERRED_ASSET_DIRS);
+    expect(re.test("/samplesX/file")).toBe(false);
+    expect(re.test("/s/samples/file")).toBe(false);
+    expect(re.test("/samples")).toBe(false);
+  });
+
+  it("escapes regex metacharacters in directory names", () => {
+    const re = deferredAssetPathPattern(["a.b"]);
+    expect(re.test("/a.b/x")).toBe(true);
+    expect(re.test("/aXb/x")).toBe(false);
+  });
+});
+
+describe("sameOriginPathMatcher", () => {
+  const matcher = sameOriginPathMatcher(deferredAssetPathPattern(DEFERRED_ASSET_DIRS));
+
+  it("matches same-origin deferred paths only", () => {
+    expect(matcher({ url: at("/loggers/fledgling.webp"), sameOrigin: true })).toBe(true);
+    expect(matcher({ url: at("/loggers/fledgling.webp"), sameOrigin: false })).toBe(false);
+    expect(matcher({ url: at("/index.html"), sameOrigin: true })).toBe(false);
+  });
+
+  it("keeps working after the toString round-trip workbox-build does", () => {
+    // The worker gets the function's source text, not the closure.
+    const revived = new Function(`return (${matcher.toString()});`)() as typeof matcher;
+    expect(revived({ url: at("/samples/okc.dovex"), sameOrigin: true })).toBe(true);
+    expect(revived({ url: at("/sim/birdseye-sim.mjs"), sameOrigin: true })).toBe(false);
+  });
+});
diff --git a/scripts/deferredAssets.ts b/scripts/deferredAssets.ts
new file mode 100644
index 00000000..0e487e0b
--- /dev/null
+++ b/scripts/deferredAssets.ts
@@ -0,0 +1,33 @@
+// Build-time helpers for the offline "deferred asset" directories (plan 0027):
+// the big public/ folders held out of the service-worker precache and runtime-
+// cached instead. `vite.config.ts` feeds the one list below into the precache
+// `globIgnores`, the emitted manifest AND the runtime-cache route, so adding a
+// directory can never leave the three disagreeing.
+//
+// Pure build tooling (Node, runs in `vite build`), never shipped to the client.
+
+/** `public/` subdirectories served from the runtime cache instead of the precache. */
+export const DEFERRED_ASSET_DIRS = ["samples", "loggers"] as const;
+
+const escapeRegExp = (text: string) => text.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+
+/** Pathname test for "is this under one of `dirs`" — e.g. `/^\/(?:samples|loggers)\//`. */
+export function deferredAssetPathPattern(dirs: readonly string[]): RegExp {
+  return new RegExp(`^\\/(?:${dirs.map(escapeRegExp).join("|")})\\/`);
+}
+
+export type SameOriginRouteMatcher = (ctx: { url: URL; sameOrigin: boolean }) => boolean;
+
+/**
+ * A Workbox `urlPattern` callback matching same-origin requests whose pathname
+ * fits `pattern`. workbox-build serializes the callback into the generated
+ * worker with `Function.prototype.toString`, where nothing from this module's
+ * scope survives — so the regex is spliced into the function's SOURCE as a
+ * literal instead of being captured by a closure.
+ */
+export function sameOriginPathMatcher(pattern: RegExp): SameOriginRouteMatcher {
+  return new Function(
+    "{ url, sameOrigin }",
+    `return sameOrigin && ${pattern.toString()}.test(url.pathname);`,
+  ) as SameOriginRouteMatcher;
+}
diff --git a/src/assets/fonts/Archivo-Variable.woff2 b/src/assets/fonts/Archivo-Variable.woff2
deleted file mode 100644
index 716d4abd..00000000
Binary files a/src/assets/fonts/Archivo-Variable.woff2 and /dev/null differ
diff --git a/src/components/FileImport.tsx b/src/components/FileImport.tsx
index 4f60fdd9..40bff814 100644
--- a/src/components/FileImport.tsx
+++ b/src/components/FileImport.tsx
@@ -2,7 +2,7 @@ import { lazy, Suspense, useCallback, useRef, useState } from "react";
 import { useTranslation, Trans } from "react-i18next";
 import { Upload, Loader2, LifeBuoy } from "lucide-react";
 import { parseDatalogContent, parseDatalogFile } from "@/lib/datalogParser";
-import { importGoProVideo, isGoProVideoFile } from "@/lib/gopro/goproImport";
+import { isGoProVideoFile } from "@/lib/gopro/goproDetect";
 import { stageGoProVideo, type StagedVideoFile } from "@/lib/gopro/videoHandoff";
 import { groupVideoRecordings } from "@/lib/videoPlaylist";
 import { ParsedData } from "@/types/racing";
@@ -95,6 +95,8 @@ export function FileImport({ onDataLoaded, autoSave, autoSaveFile }: FileImportP
         // One session per recording: a mixed selection is ambiguous, so say so
         // rather than silently picking one.
         if (!recording || groups.length > 1) throw new Error(t("fileImport.goproOneRecording"));
+        // The extractor is loaded on demand so it stays off the landing payload.
+        const { importGoProVideo } = await import("@/lib/gopro/goproImport");
         const result = await importGoProVideo(
           recording.files.map((f) => f.file),
           (p) => setProgress(t("fileImport.goproProgress", { ...p })),
diff --git a/src/components/VideoPlayer.tsx b/src/components/VideoPlayer.tsx
index 42f6fc9d..bf683a97 100644
--- a/src/components/VideoPlayer.tsx
+++ b/src/components/VideoPlayer.tsx
@@ -19,9 +19,7 @@ import { OverlaySettingsPanel } from "@/components/video-overlays/OverlaySetting
 import { VideoExportDialog, ExportOptions } from "@/components/video-overlays/VideoExportDialog";
 import { OverlayCanvas } from "@/components/video-overlays/OverlayCanvas";
 import { startVideoExport, downloadBlob, ExportContext, ExportSource } from "@/lib/videoExport";
-import { startNativeVideoExport } from "@/lib/nativeVideoExport";
 import { isNativeApp } from "@/lib/platform";
-import { insta360SdkInfo } from "@/lib/insta360/ipc";
 import { NativePlayerElement } from "@/lib/insta360/nativePlayer";
 import { DEFAULT_VIEW_POSE } from "@/lib/insta360/types";
 import { Insta360ViewLayer } from "@/components/insta360/Insta360ViewLayer";
@@ -309,7 +307,9 @@ export const VideoPlayer = memo(function VideoPlayer({
   useEffect(() => {
     if (!isNativeApp()) return;
     let alive = true;
-    void insta360SdkInfo().then((info) => { if (alive) setInsta360Available(info.available); });
+    void import("@/lib/insta360/ipc")
+      .then(({ insta360SdkInfo }) => insta360SdkInfo())
+      .then((info) => { if (alive) setInsta360Available(info.available); });
     return () => { alive = false; };
   }, []);
   const nativePlayer = state.nativeSource ? actions.videoRef.current : null;
@@ -612,7 +612,6 @@ export const VideoPlayer = memo(function VideoPlayer({
           const exportType = options.range === "lap" ? "lap" as const : "session" as const;
           const lapNum = options.range === "lap" && selectedLapNumber != null ? selectedLapNumber : undefined;
           saveSessionVideo(sessionFileName, blob, vidName, exportType, options.includeOverlays, lapNum).then(() => {
-            console.log("Video saved to app storage");
             actions.refreshStoredMeta();
           }).catch(err => {
             console.error("Failed to save video:", err);
@@ -635,15 +634,19 @@ export const VideoPlayer = memo(function VideoPlayer({
       onSavedToDevice: (uri) => {
         setIsExporting(false);
         setShowExportDialog(false);
-        console.log("Video saved to gallery:", uri);
         toast({ title: t("export.savedToGallery") });
       },
     } satisfies Parameters<typeof startVideoExport>[3];
 
     // In the native shell, the hardware pipeline does the transcode (plan
     // 0024); it resolves null when this shell can't (web, desktop stub, old
-    // app), and then the in-WebView exporter takes over unchanged.
-    void startNativeVideoExport(exportSource, exportContext, exportOptions, exportCallbacks).then(
+    // app), and then the in-WebView exporter takes over unchanged. The bridge
+    // is native-only, so the web build never downloads it.
+    const nativeExport = isNativeApp()
+      ? import("@/lib/nativeVideoExport").then(({ startNativeVideoExport }) =>
+        startNativeVideoExport(exportSource, exportContext, exportOptions, exportCallbacks))
+      : Promise.resolve(null);
+    void nativeExport.then(
       (native) => {
         if (!native) startVideoExport(exportSource, exportContext, exportOptions, exportCallbacks);
       },
diff --git a/src/components/drawer/SetupHistoryPanel.tsx b/src/components/drawer/SetupHistoryPanel.tsx
index f436f9b1..3ff3def5 100644
--- a/src/components/drawer/SetupHistoryPanel.tsx
+++ b/src/components/drawer/SetupHistoryPanel.tsx
@@ -49,6 +49,9 @@ export function SetupHistoryPanel({
   // Revision awaiting rollback confirmation.
   const [rollbackTarget, setRollbackTarget] = useState<SetupRevision | null>(null);
   const [busy, setBusy] = useState(false);
+  const [loadFailed, setLoadFailed] = useState(false);
+  // Bumped by the error state's Retry button to re-run the load effect.
+  const [reloadKey, setReloadKey] = useState(0);
 
   const load = useCallback(async () => {
     // Sweep first so the panel always matches the retention notice it shows.
@@ -59,28 +62,47 @@ export function SetupHistoryPanel({
 
   useEffect(() => {
     let cancelled = false;
-    load().then(({ revs, m }) => {
-      if (cancelled) return;
-      setRevisions(revs);
-      setMetas(m);
-      setLoading(false);
-    });
+    setLoading(true);
+    setLoadFailed(false);
+    load()
+      .then(({ revs, m }) => {
+        if (cancelled) return;
+        setRevisions(revs);
+        setMetas(m);
+      })
+      // A failed IndexedDB read must not leave the panel on "Loading…" forever.
+      .catch(() => {
+        if (!cancelled) setLoadFailed(true);
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
     return () => {
       cancelled = true;
     };
-  }, [load]);
+  }, [load, reloadKey]);
 
   // Rollback / duplicate both save a setup (which freezes a revision), so the
   // list is reloaded afterwards to show the result.
   const runAction = useCallback(
-    async (action: () => Promise<void>, done: string) => {
+    async (action: () => Promise<void>, done: string, failed: string) => {
       setBusy(true);
       try {
-        await action();
-        const { revs, m } = await load();
-        setRevisions(revs);
-        setMetas(m);
+        try {
+          await action();
+        } catch {
+          toast.error(failed);
+          return;
+        }
         toast.success(done);
+        try {
+          const { revs, m } = await load();
+          setRevisions(revs);
+          setMetas(m);
+          setLoadFailed(false);
+        } catch {
+          setLoadFailed(true);
+        }
       } finally {
         setBusy(false);
       }
@@ -92,13 +114,21 @@ export function SetupHistoryPanel({
     const target = rollbackTarget;
     if (!target || !onRollback) return;
     setRollbackTarget(null);
-    void runAction(() => onRollback(target), t("setupHistory.rollbackDone", { hash: shortRevHash(target.id) }));
+    void runAction(
+      () => onRollback(target),
+      t("setupHistory.rollbackDone", { hash: shortRevHash(target.id) }),
+      t("setupHistory.rollbackFailed"),
+    );
   };
 
   const duplicate = (revision: SetupRevision) => {
     if (!onDuplicate) return;
     const name = t("setupHistory.duplicateName", { name: revision.name });
-    void runAction(() => onDuplicate(revision), t("setupHistory.duplicateDone", { name }));
+    void runAction(
+      () => onDuplicate(revision),
+      t("setupHistory.duplicateDone", { name }),
+      t("setupHistory.duplicateFailed"),
+    );
   };
 
   const history = useMemo(
@@ -189,6 +219,13 @@ export function SetupHistoryPanel({
       <div className="flex-1 overflow-y-auto px-3 py-3 space-y-3">
         {loading ? (
           <p className="text-center text-xs text-muted-foreground py-8">{t("setupHistory.loading")}</p>
+        ) : loadFailed ? (
+          <div role="alert" className="flex flex-col items-center gap-3 py-8 text-center">
+            <p className="text-xs text-destructive">{t("setupHistory.loadFailed")}</p>
+            <Button variant="outline" size="sm" onClick={() => setReloadKey((k) => k + 1)}>
+              {t("setupHistory.retry")}
+            </Button>
+          </div>
         ) : history.entries.length === 0 ? (
           <div className="flex flex-col items-center justify-center text-muted-foreground gap-3 py-16">
             <History className="w-12 h-12 opacity-30" />
diff --git a/src/hooks/useDataLoader.test.ts b/src/hooks/useDataLoader.test.ts
index 57835b1d..8339872a 100644
--- a/src/hooks/useDataLoader.test.ts
+++ b/src/hooks/useDataLoader.test.ts
@@ -1,6 +1,12 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import type { Lap, TrackCourseSelection } from "@/types/racing";
-import { applyCourselessLaps, detectionMetadataPatch, dragMetadataPatch } from "./useDataLoader";
+import {
+  applyCourselessLaps,
+  chooseAutoDetectPath,
+  detectionMetadataPatch,
+  dragMetadataPatch,
+  shouldRestoreDragSession,
+} from "./useDataLoader";
 
 const laps = [
   { lapNumber: 1, lapTimeMs: 65000 },
@@ -67,6 +73,44 @@ describe("dragMetadataPatch (drag-session tagging)", () => {
   });
 });
 
+describe("chooseAutoDetectPath (load precedence, plan 0022)", () => {
+  const drag = { runs: [] };
+
+  it("a confident course wins and never runs drag detection", () => {
+    const detectDrag = vi.fn(() => drag);
+    expect(chooseAutoDetectPath({ isWaypointMode: false }, detectDrag)).toEqual({ kind: "course" });
+    expect(detectDrag).not.toHaveBeenCalled();
+  });
+
+  it("drag runs beat a waypoint result", () => {
+    expect(chooseAutoDetectPath({ isWaypointMode: true }, () => drag)).toEqual({ kind: "drag", drag });
+  });
+
+  it("drag runs are found even when no course detected at all", () => {
+    expect(chooseAutoDetectPath(null, () => drag)).toEqual({ kind: "drag", drag });
+  });
+
+  it("falls back to waypoint, then to the nearest-track prompt", () => {
+    expect(chooseAutoDetectPath({ isWaypointMode: true }, () => null)).toEqual({ kind: "waypoint" });
+    expect(chooseAutoDetectPath(null, () => null)).toEqual({ kind: "nearest" });
+  });
+});
+
+describe("shouldRestoreDragSession (saved drag tag)", () => {
+  it("restores a recognised distance when no course was restored", () => {
+    expect(shouldRestoreDragSession(false, 1320)).toBe(true);
+  });
+
+  it("a restored track/course shadows a stale drag tag", () => {
+    expect(shouldRestoreDragSession(true, 1320)).toBe(false);
+  });
+
+  it("ignores a missing or unrecognised distance", () => {
+    expect(shouldRestoreDragSession(false, undefined)).toBe(false);
+    expect(shouldRestoreDragSession(false, 1234)).toBe(false);
+  });
+});
+
 describe("applyCourselessLaps (drag / waypoint pre-application)", () => {
   function sink(initial: TrackCourseSelection | null) {
     const state = { selection: initial, laps: [] as Lap[], selected: null as number | null };
diff --git a/src/hooks/useDataLoader.ts b/src/hooks/useDataLoader.ts
index afade4dc..4f01eaa9 100644
--- a/src/hooks/useDataLoader.ts
+++ b/src/hooks/useDataLoader.ts
@@ -129,6 +129,45 @@ export function applyCourselessLaps(sink: CourselessLapSink, laps: Lap[]): void
   sink.setSelectedLapNumber(fastestRankedLap(laps)?.lapNumber ?? null);
 }
 
+/**
+ * Whether a saved drag tag should restore this session as drag runs (plan
+ * 0022). A track/course restored from the same metadata shadows a stale drag
+ * tag, and only a recognised scoring distance counts. Pure so the load
+ * precedence stays testable.
+ */
+export function shouldRestoreDragSession(
+  restoredCourse: boolean,
+  storedDragDistanceFt: unknown,
+): storedDragDistanceFt is DragDistanceFt {
+  return !restoredCourse && isDragDistanceFt(storedDragDistanceFt);
+}
+
+/** Which branch a fresh (un-restored) load takes after auto-detection. */
+export type AutoDetectPath<D> =
+  | { kind: "course" }
+  | { kind: "drag"; drag: D }
+  | { kind: "waypoint" }
+  | { kind: "nearest" };
+
+/**
+ * Load precedence after auto-detection (plan 0022): a confident course wins
+ * outright (drag detection never even runs); otherwise drag-strip runs beat a
+ * waypoint result — a drag session's return road loops back near the staging
+ * lanes, so waypoint mode would mis-time out-and-back passes as laps; then
+ * waypoint; then the nearest-track prompt. `detectDrag` is a thunk so the scan
+ * only costs anything when a course didn't match. Pure so it stays testable.
+ */
+export function chooseAutoDetectPath<D>(
+  detection: Pick<CourseDetectionResult, "isWaypointMode"> | null,
+  detectDrag: () => D | null,
+): AutoDetectPath<D> {
+  if (detection && !detection.isWaypointMode) return { kind: "course" };
+  const drag = detectDrag();
+  if (drag) return { kind: "drag", drag };
+  if (detection) return { kind: "waypoint" };
+  return { kind: "nearest" };
+}
+
 /**
  * File-load orchestration: connects sessionData (parsing), lapMgmt (lap calc),
  * sessionMeta (per-file kart/setup/weather metadata), and the track-prompt UI.
@@ -213,7 +252,7 @@ export function useDataLoader({
           // stored distance (a track/course restore above shadows a stale drag
           // tag; a corrupt file that no longer detects falls through to normal
           // detection).
-          if (!restoredFromMeta && isDragDistanceFt(meta.dragDistanceFt)) {
+          if (shouldRestoreDragSession(restoredFromMeta, meta.dragDistanceFt)) {
             const drag = detectDragRuns(parsedData.samples);
             if (drag) {
               applyDrag(parsedData.samples, drag, meta.dragDistanceFt, fileName, parsedData.startDate);
@@ -255,8 +294,9 @@ export function useDataLoader({
         tracksForRaceMode(tracks, parsedData.dovexMetadata?.raceMode),
       );
       setDetectionResult(detection);
+      const path = chooseAutoDetectPath(detection, () => detectDragRuns(parsedData.samples));
 
-      if (detection && !detection.isWaypointMode) {
+      if (path.kind === "course" && detection) {
         // Auto-detected a real course — apply directly, no prompt needed
         lapMgmt.setSelection({
           trackName: detection.track.name,
@@ -284,12 +324,10 @@ export function useDataLoader({
         return;
       }
 
-      // No confident course match. Check for drag-strip data BEFORE accepting a
-      // waypoint result: a drag session's return road loops back near the
-      // staging lanes, so waypoint mode happily mis-times out-and-back passes
-      // as "laps".
-      const drag = detectDragRuns(parsedData.samples);
-      if (drag) {
+      // No confident course match: drag-strip data beats a waypoint result
+      // (see chooseAutoDetectPath).
+      if (path.kind === "drag") {
+        const { drag } = path;
         // Pre-apply at the suggested distance (mirrors the waypoint branch's
         // optimistic laps); nothing persists until the user confirms.
         applyDrag(parsedData.samples, drag, drag.suggestedDistanceFt, undefined, undefined, false);
@@ -298,7 +336,7 @@ export function useDataLoader({
         return;
       }
 
-      if (detection && detection.isWaypointMode) {
+      if (path.kind === "waypoint" && detection) {
         // Waypoint mode — apply laps and prompt the user to confirm
         applyCourselessLaps(lapMgmt, detection.laps);
         setDetectedTrack(null);
diff --git a/src/hooks/useOfflineReadiness.ts b/src/hooks/useOfflineReadiness.ts
index e98f4b4c..59e01b5a 100644
--- a/src/hooks/useOfflineReadiness.ts
+++ b/src/hooks/useOfflineReadiness.ts
@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useState } from "react";
 import {
   computeReadiness,
+  countCachedAssets,
   readinessPercent,
   type OfflineReadiness,
 } from "@/lib/offlineReadiness";
@@ -24,13 +25,6 @@ export interface OfflineReadinessState {
 const supported = () =>
   typeof navigator !== "undefined" && "serviceWorker" in navigator;
 
-// Counts only entries at the manifest's current revision: a stale copy from an
-// older build is exactly what the next warm-up will replace.
-const countCached = async (assets: DeferredAsset[]): Promise<number> => {
-  const hits = await Promise.all(assets.map(isDeferredAssetCached));
-  return hits.filter(Boolean).length;
-};
-
 /**
  * Live "can this device work with no signal?" state, plus a way to finish the
  * job on demand. Backed by `lib/offlineReadiness` (pure) and `lib/offlineWarmup`
@@ -46,7 +40,7 @@ export function useOfflineReadiness(): OfflineReadinessState & {
 
   const refresh = useCallback(async (list: DeferredAsset[]) => {
     setControlled(supported() && navigator.serviceWorker.controller !== null);
-    setCached(await countCached(list));
+    setCached(await countCachedAssets(list, isDeferredAssetCached));
   }, []);
 
   useEffect(() => {
diff --git a/src/hooks/useVideoSync.ts b/src/hooks/useVideoSync.ts
index 96e6ee7c..ae403ce5 100644
--- a/src/hooks/useVideoSync.ts
+++ b/src/hooks/useVideoSync.ts
@@ -2,12 +2,11 @@ import { useState, useRef, useCallback, useEffect, useMemo } from "react";
 import { GpsSample } from "@/types/racing";
 import { saveVideoSync, loadVideoSync, VideoSyncRecord, VideoSyncChunk } from "@/lib/videoStorage";
 import { loadSessionVideo, hasSessionVideo, deleteSessionVideo, getSessionVideoMeta, type StoredVideoMeta } from "@/lib/videoFileStorage";
-import { NativePlayerElement, type VideoSurface } from "@/lib/insta360/nativePlayer";
+import type { NativePlayerElement, VideoSurface } from "@/lib/insta360/nativePlayer";
 import type { Insta360CameraFile } from "@/lib/insta360/types";
 import {
-  getNativeStoredVideo, storeNativeVideo,
   NATIVE_VIDEO_STORE_CHANGED, type NativeVideoStoreChangedDetail,
-} from "@/lib/nativeVideoStore";
+} from "@/lib/nativeVideoStoreEvents";
 import { isNativeApp } from "@/lib/platform";
 import type { OverlaySettings } from "@/components/video-overlays/types";
 import { DEFAULT_OVERLAY_SETTINGS } from "@/components/video-overlays/types";
@@ -17,6 +16,14 @@ import { buildPlaylist, groupVideoRecordings, virtualToLocal, localToVirtual, ty
 import { takeStagedGoProVideo, type StagedGoProVideo } from "@/lib/gopro/videoHandoff";
 import { createLatestGate } from "@/lib/latestGate";
 
+// Native-shell-only modules (plans 0024/0025), loaded on first use so the web
+// build's main chunk never carries the store bridge or the camera player. Every
+// caller is already behind `isNativeApp()` or a native-only action.
+const getNativeStoredVideo = async (fileName: string) =>
+  (await import("@/lib/nativeVideoStore")).getNativeStoredVideo(fileName);
+const storeNativeVideo = async (fileName: string, file: File) =>
+  (await import("@/lib/nativeVideoStore")).storeNativeVideo(fileName, file);
+
 interface UseVideoSyncOptions {
   samples: GpsSample[];
   allSamples: GpsSample[];
@@ -518,6 +525,7 @@ export function useVideoSync({ samples, allSamples, currentIndex, onScrub, sessi
   // aren't copied into the store, and can't be exported (v1).
   const loadCameraRecording = useCallback(async (file: Insta360CameraFile, size: { width: number; height: number }) => {
     revokeAllUrls();
+    const { NativePlayerElement } = await import("@/lib/insta360/nativePlayer");
     const player = new NativePlayerElement(file, { width: size.width, height: size.height });
     nativePlayerRef.current = player;
     setNativeSource({ kind: "insta360", file, is360: file.is360 });
diff --git a/src/index.css b/src/index.css
index 3072f4ed..d28dd20f 100644
--- a/src/index.css
+++ b/src/index.css
@@ -14,15 +14,10 @@
 /* Archivo is the PerchWerks/LapWing brand typeface (perchwerks-style/fonts).
    It's used only for display type (`font-brand`) — the dense app UI stays on
    Inter so tables and toolbars keep their metrics. Bundled from src/ so Vite
-   hashes it into the SW precache like the @fontsource files. */
-@font-face {
-  font-family: "Archivo";
-  src: url("./assets/fonts/Archivo-Variable.woff2") format("woff2");
-  font-weight: 100 900;
-  font-style: normal;
-  font-display: swap;
-}
-
+   hashes it into the SW precache like the @fontsource files.
+   Only the italic face ships: every `font-brand` use is italic, and the upright
+   variable face was ~35 KB of precache no page ever rendered. Add it back
+   (Archivo-Variable.woff2, font-style: normal) if upright brand type appears. */
 @font-face {
   font-family: "Archivo";
   src: url("./assets/fonts/Archivo-Variable-Italic.woff2") format("woff2");
diff --git a/src/lib/datalogParser.ts b/src/lib/datalogParser.ts
index 3433bdc3..2a11b175 100644
--- a/src/lib/datalogParser.ts
+++ b/src/lib/datalogParser.ts
@@ -11,7 +11,7 @@ import { parseAimFile, isAimFormat, hasAimSignature } from './aimParser';
 import { isMotecLdFormat, parseMotecLdFile, isMotecCsvFormat, parseMotecCsvFile } from './motecParser';
 import { isIracingFormat, parseIracingFile } from './iracingParser';
 import { isXrkFile, parseXrkFile, type XrkProgressCallback } from './xrk/xrkImporter';
-import { isGoProVideoBuffer, isGoProVideoFile, parseGoProVideoFile } from './gopro/goproImport';
+import { isGoProVideoBuffer, isGoProVideoFile } from './gopro/goproDetect';
 import { beginFileLoading, updateFileLoading, endFileLoading } from './fileLoadingState';
 
 /**
@@ -73,6 +73,8 @@ async function routeDatalogFile(
   // this MUST come before the whole-file `arrayBuffer()` below (a camera file
   // is gigabytes; its telemetry is a few hundred KB).
   if (isGoProVideoFile(file.name)) {
+    // The MP4/GPMF extractor loads only when a video actually arrives.
+    const { parseGoProVideoFile } = await import('./gopro/goproImport');
     return parseGoProVideoFile(file, (p) => onProgress?.({
       phase: 'parse',
       message: `Reading GoPro telemetry… ${p.done}/${p.total}`,
diff --git a/src/lib/gopro/goproDetect.ts b/src/lib/gopro/goproDetect.ts
new file mode 100644
index 00000000..7570683a
--- /dev/null
+++ b/src/lib/gopro/goproDetect.ts
@@ -0,0 +1,27 @@
+/**
+ * Cheap GoPro-video gates (plan 0029). Split from the importer because the
+ * eager file-routing code (`datalogParser`, `FileImport`) needs to *recognise*
+ * a video on every import, while the MP4/GPMF extractor itself only loads
+ * when one actually arrives — keeping it off the main chunk.
+ */
+
+/** Containers a GoPro writes; `.360` is the MAX/Fusion spherical variant. */
+const GOPRO_VIDEO_EXTENSIONS = [".mp4", ".mov", ".360"];
+
+/** Name-based gate used before any bytes are read. */
+export function isGoProVideoFile(name: string): boolean {
+  const lower = name.toLowerCase();
+  return GOPRO_VIDEO_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+
+/** True when the buffer opens with an ISO-BMFF `ftyp` box (MP4/MOV/.360). */
+export function isIsoBmff(buffer: ArrayBuffer): boolean {
+  if (buffer.byteLength < 12) return false;
+  const view = new DataView(buffer);
+  return String.fromCharCode(view.getUint8(4), view.getUint8(5), view.getUint8(6), view.getUint8(7)) === "ftyp";
+}
+
+/** True for an in-memory MP4/MOV — the sync content router refuses these. */
+export function isGoProVideoBuffer(buffer: ArrayBuffer): boolean {
+  return isIsoBmff(buffer);
+}
diff --git a/src/lib/gopro/goproImport.ts b/src/lib/gopro/goproImport.ts
index 9d0bae1e..7e669cda 100644
--- a/src/lib/gopro/goproImport.ts
+++ b/src/lib/gopro/goproImport.ts
@@ -7,22 +7,10 @@ import type { ParsedData } from "@/types/racing";
 import { parseDoveFile } from "@/lib/doveParser";
 import { orderVideoFiles } from "@/lib/videoPlaylist";
 import { beginFileLoading, updateFileLoading, endFileLoading } from "@/lib/fileLoadingState";
-import { blobByteSource, isIsoBmff, readGpmdTrack, readSamples } from "./mp4Boxes";
+import { blobByteSource, readGpmdTrack, readSamples } from "./mp4Boxes";
 import { buildGoProSession, rowsFromPayloads, type GoProGpsRow, type GoProSession } from "./goproTelemetry";
 
-/** Containers a GoPro writes; `.360` is the MAX/Fusion spherical variant. */
-const GOPRO_VIDEO_EXTENSIONS = [".mp4", ".mov", ".360"];
-
-/** Cheap name-based gate used before any bytes are read. */
-export function isGoProVideoFile(name: string): boolean {
-  const lower = name.toLowerCase();
-  return GOPRO_VIDEO_EXTENSIONS.some((ext) => lower.endsWith(ext));
-}
-
-/** True for an in-memory MP4/MOV — the sync content router refuses these. */
-export function isGoProVideoBuffer(buffer: ArrayBuffer): boolean {
-  return isIsoBmff(buffer);
-}
+export { isGoProVideoBuffer, isGoProVideoFile } from "./goproDetect";
 
 /** The session file name a video import is saved under: `GH010042.MP4` → `GH010042.dove`. */
 export function goProSessionFileName(videoName: string): string {
diff --git a/src/lib/gopro/goproTelemetry.test.ts b/src/lib/gopro/goproTelemetry.test.ts
index f49501eb..c810202a 100644
--- a/src/lib/gopro/goproTelemetry.test.ts
+++ b/src/lib/gopro/goproTelemetry.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 import { buildGoProSession, rowsFromPayloads, type GoProPayload } from "./goproTelemetry";
-import { acclOnlyPayload, gps5Payload, gps9Payload } from "./testFixtures";
+import { acclOnlyPayload, gpmfComplex, gpmfNested, gpmfString, gps5Payload, gps9Payload } from "./testFixtures";
 import { parseDoveFile } from "@/lib/doveParser";
 
 const buf = (bytes: Uint8Array) => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
@@ -32,6 +32,16 @@ describe("rowsFromPayloads", () => {
     expect(rows.map((r) => r.tSec)).toEqual([5, 5.2]);
   });
 
+  it("skips a malformed payload and keeps importing the rest", () => {
+    const bad = gpmfNested("DEVC", [
+      gpmfNested("STRM", [gpmfString("TYPE", "lllllllSx"), gpmfComplex("GPS9", "lllllllSS", [[1, 2, 3, 4, 5, 6, 7, 8, 3]])]),
+    ]);
+    const good = gps5Payload([{ lat: 33.5, lon: -117.7, alt: 0, speed2d: 1 }], { gpsu: "240615143025.000" });
+    const rows = rowsFromPayloads([payload(bad, 0), payload(good, 1)]);
+    expect(rows).toHaveLength(1);
+    expect(rows[0].tSec).toBe(1);
+  });
+
   it("rejects zero/out-of-range coordinates and skips payloads without GPS", () => {
     const rows = rowsFromPayloads([
       payload(gps5Payload([{ lat: 0, lon: 0, alt: 0, speed2d: 0 }, { lat: 95, lon: 10, alt: 0, speed2d: 0 }, { lat: 33.5, lon: -117.7, alt: 0, speed2d: 1 }]), 0),
diff --git a/src/lib/gopro/gpmf.test.ts b/src/lib/gopro/gpmf.test.ts
index 6bc6d79c..795169dc 100644
--- a/src/lib/gopro/gpmf.test.ts
+++ b/src/lib/gopro/gpmf.test.ts
@@ -55,6 +55,11 @@ describe("value readers", () => {
     const bytes = gpmfComplex("GPS9", "l", [[1]]);
     expect(() => readComplex(view(bytes), parseGpmf(view(bytes))[0], "x")).toThrow(/unsupported/);
   });
+
+  it("rejects a TYPE wider than the record instead of reading the next one", () => {
+    const bytes = gpmfComplex("GPS9", "l", [[1], [2]]);
+    expect(() => readComplex(view(bytes), parseGpmf(view(bytes))[0], "ll")).toThrow(/exceeds/);
+  });
 });
 
 describe("parseGpsu", () => {
@@ -107,6 +112,27 @@ describe("extractGpsPayload", () => {
     expect(gps?.utcMs).toBe(utc);
   });
 
+  it("returns null (skip) for a malformed GPS9 stream instead of throwing", () => {
+    // Regression (A4): an unknown TYPE char used to throw out of the whole import.
+    const bytes = gpmfNested("DEVC", [
+      gpmfNested("STRM", [gpmfString("TYPE", "lllllllSx"), gpmfComplex("GPS9", "lllllllSS", [[1, 2, 3, 4, 5, 6, 7, 8, 3]])]),
+    ]);
+    expect(extractGpsPayload(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength))).toBeNull();
+  });
+
+  it("falls back to GPS5 when the payload's GPS9 stream is malformed", () => {
+    const gps5 = gps5Payload([{ lat: 33.5, lon: -117.7, alt: 1, speed2d: 1 }]);
+    const bytes = concat([
+      gpmfNested("DEVC", [
+        gpmfNested("STRM", [gpmfString("TYPE", "x"), gpmfComplex("GPS9", "l", [[1]])]),
+      ]),
+      gps5,
+    ]);
+    const gps = extractGpsPayload(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+    expect(gps?.source).toBe("GPS5");
+    expect(gps?.fixes[0].lat).toBeCloseTo(33.5, 6);
+  });
+
   it("returns null for a payload without a GPS stream", () => {
     const bytes = acclOnlyPayload();
     expect(extractGpsPayload(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength))).toBeNull();
diff --git a/src/lib/gopro/gpmf.ts b/src/lib/gopro/gpmf.ts
index 8e8c6ee6..a8d3a154 100644
--- a/src/lib/gopro/gpmf.ts
+++ b/src/lib/gopro/gpmf.ts
@@ -104,15 +104,24 @@ export function readString(view: DataView, item: GpmfItem): string {
  */
 export function readComplex(view: DataView, item: GpmfItem, typeString: string): number[][] {
   const fields = typeString.split("").filter((c) => c !== "\0");
+  let recordSize = 0;
+  for (const typeChar of fields) {
+    const size = TYPE_SIZES[typeChar];
+    if (!size) throw new Error(`GPMF: unsupported TYPE field '${typeChar}'`);
+    recordSize += size;
+  }
+  // A TYPE wider than the record would read into the next record (or past the
+  // payload), so treat the mismatch as corruption rather than decode garbage.
+  if (recordSize > item.structSize) {
+    throw new Error(`GPMF: TYPE '${typeString}' (${recordSize} B) exceeds the ${item.structSize} B record`);
+  }
   const rows: number[][] = [];
   for (let r = 0; r < item.repeat; r++) {
     let offset = item.dataOffset + r * item.structSize;
     const row: number[] = [];
     for (const typeChar of fields) {
-      const size = TYPE_SIZES[typeChar];
-      if (!size) throw new Error(`GPMF: unsupported TYPE field '${typeChar}'`);
       row.push(readScalar(view, offset, typeChar));
-      offset += size;
+      offset += TYPE_SIZES[typeChar];
     }
     rows.push(row);
   }
@@ -221,7 +230,8 @@ function decodeGps5(view: DataView, stream: Map<string, GpmfItem>): GpmfGpsPaylo
 
 /**
  * Pull the GPS stream out of one `gpmd` payload. Prefers GPS9 (HERO11+,
- * per-sample time/DOP/fix) over GPS5. Null when the payload has no GPS stream.
+ * per-sample time/DOP/fix) over GPS5. Null when the payload has no GPS stream
+ * or its GPS stream is malformed (the caller skips the payload).
  */
 export function extractGpsPayload(buffer: ArrayBuffer): GpmfGpsPayload | null {
   const view = new DataView(buffer);
@@ -233,12 +243,26 @@ export function extractGpsPayload(buffer: ArrayBuffer): GpmfGpsPayload | null {
     }
   }
   for (const stream of streams) {
-    const gps9 = decodeGps9(view, stream);
+    const gps9 = decodeOrSkip(() => decodeGps9(view, stream));
     if (gps9) return gps9;
   }
   for (const stream of streams) {
-    const gps5 = decodeGps5(view, stream);
+    const gps5 = decodeOrSkip(() => decodeGps5(view, stream));
     if (gps5) return gps5;
   }
   return null;
 }
+
+/**
+ * One corrupt stream (an unknown TYPE character, a record that runs past the
+ * payload) must cost that payload's GPS, not the whole import: a GoPro file
+ * carries one payload per second, so skipping a bad one leaves a one-second
+ * gap while throwing would reject an hour of otherwise good telemetry.
+ */
+function decodeOrSkip(decode: () => GpmfGpsPayload | null): GpmfGpsPayload | null {
+  try {
+    return decode();
+  } catch {
+    return null;
+  }
+}
diff --git a/src/lib/gopro/mp4Boxes.test.ts b/src/lib/gopro/mp4Boxes.test.ts
index 2ec0160d..2a2f8438 100644
--- a/src/lib/gopro/mp4Boxes.test.ts
+++ b/src/lib/gopro/mp4Boxes.test.ts
@@ -46,6 +46,15 @@ describe("readGpmdTrack", () => {
     expect(await readGpmdTrack(bufferByteSource(new ArrayBuffer(3)))).toBeNull();
   });
 
+  it("caps a hostile uniform stsz count against the file size instead of allocating it", async () => {
+    // Regression (SEC-1): a ~4-billion-entry uniform stsz used to hang/OOM the tab.
+    const file = buildGoProMp4({ payloads, uniformStsz: { size: 1, count: 0xffff_fffe } });
+    const track = await readGpmdTrack(bufferByteSource(file));
+    // Three one-sample chunks bound what resolves; the cap bounds what is allocated.
+    expect(track!.samples).toHaveLength(3);
+    expect(track!.samples.every((s) => s.size === 1)).toBe(true);
+  });
+
   it("leaves the creation time undefined when the camera wrote none", async () => {
     const track = await readGpmdTrack(bufferByteSource(buildGoProMp4({ payloads })));
     expect(track!.creationEpochMs).toBeUndefined();
diff --git a/src/lib/gopro/mp4Boxes.ts b/src/lib/gopro/mp4Boxes.ts
index 5ed4c6a1..4711bf0b 100644
--- a/src/lib/gopro/mp4Boxes.ts
+++ b/src/lib/gopro/mp4Boxes.ts
@@ -110,12 +110,7 @@ function findChild(view: DataView, start: number, end: number, type: string): Bo
   return null;
 }
 
-/** True when the buffer opens with an ISO-BMFF `ftyp` box (MP4/MOV/.360). */
-export function isIsoBmff(buffer: ArrayBuffer): boolean {
-  if (buffer.byteLength < 12) return false;
-  const view = new DataView(buffer);
-  return fourcc(view, 4) === "ftyp";
-}
+export { isIsoBmff } from "./goproDetect";
 
 /**
  * Walk the top-level boxes with ranged reads and return the `moov` payload.
@@ -178,10 +173,17 @@ function readTable(view: DataView, box: BoxRef, width: 1 | 2): number[] | [numbe
   return out as number[] | [number, number][];
 }
 
-function readStsz(view: DataView, box: BoxRef): number[] {
+/**
+ * `stsz` sample sizes. The explicit-size form is bounded by the box itself, but
+ * the uniform form is just a size and a uint32 count — a hostile file can ask
+ * for ~4 billion entries, which hangs or OOMs the tab. Every sample occupies
+ * `uniform` bytes of the file, so no honest table can list more than
+ * `fileSize / uniform` of them; cap the count there.
+ */
+function readStsz(view: DataView, box: BoxRef, fileSize: number): number[] {
   const uniform = view.getUint32(box.bodyStart + 4);
   const count = view.getUint32(box.bodyStart + 8);
-  if (uniform !== 0) return new Array<number>(count).fill(uniform);
+  if (uniform !== 0) return new Array<number>(Math.min(count, Math.floor(fileSize / uniform))).fill(uniform);
   const sizes: number[] = [];
   let offset = box.bodyStart + 12;
   for (let i = 0; i < count && offset + 4 <= box.end; i++, offset += 4) {
@@ -210,14 +212,14 @@ function readCo64(view: DataView, box: BoxRef): number[] {
   return offsets;
 }
 
-function readStbl(view: DataView, stbl: BoxRef): { format: string | null; table: SampleTable } {
+function readStbl(view: DataView, stbl: BoxRef, fileSize: number): { format: string | null; table: SampleTable } {
   let format: string | null = null;
   const table: SampleTable = { sizes: [], chunkOffsets: [], chunkRuns: [], timeRuns: [] };
   for (const box of children(view, stbl.bodyStart, stbl.end)) {
     switch (box.type) {
       case "stsd": format = readStsd(view, box); break;
       case "stts": table.timeRuns = readTable(view, box, 2) as [number, number][]; break;
-      case "stsz": table.sizes = readStsz(view, box); break;
+      case "stsz": table.sizes = readStsz(view, box, fileSize); break;
       case "stsc": table.chunkRuns = readStsc(view, box); break;
       case "stco": table.chunkOffsets = readTable(view, box, 1) as number[]; break;
       case "co64": table.chunkOffsets = readCo64(view, box); break;
@@ -312,7 +314,7 @@ export async function readGpmdTrack(src: ByteSource): Promise<GpmdTrack | null>
     const minf = findChild(view, mdia.bodyStart, mdia.end, "minf");
     const stbl = minf && findChild(view, minf.bodyStart, minf.end, "stbl");
     if (!stbl) continue;
-    const { format, table } = readStbl(view, stbl);
+    const { format, table } = readStbl(view, stbl, src.size);
     if (format !== "gpmd") continue;
     const mdhd = findChild(view, mdia.bodyStart, mdia.end, "mdhd");
     const timescale = mdhd ? readMdhdTimescale(view, mdhd) : 0;
diff --git a/src/lib/gopro/testFixtures.ts b/src/lib/gopro/testFixtures.ts
index 89f9fc94..550587aa 100644
--- a/src/lib/gopro/testFixtures.ts
+++ b/src/lib/gopro/testFixtures.ts
@@ -185,6 +185,8 @@ export interface Mp4Options {
   withVideoTrack?: boolean;
   /** Use a 64-bit `co64` chunk table. */
   co64?: boolean;
+  /** Write a uniform-size `stsz` (size + count) instead of a per-sample list. */
+  uniformStsz?: { size: number; count: number };
 }
 
 /**
@@ -211,7 +213,9 @@ export function buildGoProMp4(opts: Mp4Options): ArrayBuffer {
     for (const p of opts.payloads) { offsets.push(cursor); cursor += p.byteLength; }
 
     const stts = fullBox("stts", u32(durations.length), ...durations.map((d) => u32(1, d)));
-    const stsz = fullBox("stsz", u32(0), u32(opts.payloads.length), ...opts.payloads.map((p) => u32(p.byteLength)));
+    const stsz = opts.uniformStsz
+      ? fullBox("stsz", u32(opts.uniformStsz.size), u32(opts.uniformStsz.count))
+      : fullBox("stsz", u32(0), u32(opts.payloads.length), ...opts.payloads.map((p) => u32(p.byteLength)));
     const stsc = fullBox("stsc", u32(1), u32(1, 1, 1));
     const stco = opts.co64
       ? fullBox("co64", u32(offsets.length), ...offsets.map((o) => u32(0, o)))
diff --git a/src/lib/insta360/ipc.ts b/src/lib/insta360/ipc.ts
index b5c01a97..5bffcdaf 100644
--- a/src/lib/insta360/ipc.ts
+++ b/src/lib/insta360/ipc.ts
@@ -3,8 +3,8 @@
  * lazy loader in `loggers/native/ipc.ts` so `@tauri-apps/api` stays out of
  * the web bundle. Errors are plain strings; an `unsupported:` prefix means
  * this shell can't talk to a camera (desktop, or an Android build without
- * the SDK) — `isInsta360Unavailable` folds a shell that predates these
- * commands into the same answer.
+ * the SDK) — `isNativeFeatureUnavailable` (`lib/nativeUnavailable.ts`) folds
+ * a shell that predates these commands into the same answer.
  */
 
 import { api } from "@/lib/loggers/native/ipc";
@@ -23,12 +23,6 @@ import type {
   ViewPose,
 } from "./types";
 
-/** The stub sentinel, or a shell that doesn't know the command at all. */
-export function isInsta360Unavailable(err: unknown): boolean {
-  const msg = String(err);
-  return msg.startsWith("unsupported:") || /unknown|not found|not allowed/i.test(msg);
-}
-
 /**
  * Whether this shell can talk to an Insta360 camera. Resolves `false` off
  * native, on the stubs, and on a shell that predates the feature — never
diff --git a/src/lib/insta360/nativePlayer.test.ts b/src/lib/insta360/nativePlayer.test.ts
index da2e9355..f25cf3dc 100644
--- a/src/lib/insta360/nativePlayer.test.ts
+++ b/src/lib/insta360/nativePlayer.test.ts
@@ -198,4 +198,43 @@ describe("NativePlayerElement", () => {
     await expect(opening).rejects.toThrow(/closed/);
     expect(close).toHaveBeenCalled();
   });
+
+  it("a superseded player's late close does not kill the newer stream", async () => {
+    // Regression (B6): the shell's close carries no player id.
+    const close = vi.fn(async () => {});
+    const info: Insta360PlayerInfo = { streamUrl: "u", width: 640, height: 360, durationMs: 1, is360: false };
+    const make = () =>
+      new NativePlayerElement(file, {
+        width: 640, height: 360, open: async () => info, control: async () => {}, close, setView: async (p) => p,
+      });
+    const first = make();
+    await first.open();
+    const second = make();
+    await second.open();
+    first.close();
+    expect(close).not.toHaveBeenCalled();
+    second.close();
+    expect(close).toHaveBeenCalledTimes(1);
+  });
+
+  it("an open that resolves after a newer player opened leaves the newer one alone", async () => {
+    const close = vi.fn(async () => {});
+    let resolveFirst: ((i: Insta360PlayerInfo) => void) | null = null;
+    const info: Insta360PlayerInfo = { streamUrl: "u", width: 640, height: 360, durationMs: 1, is360: false };
+    const first = new NativePlayerElement(file, {
+      width: 640, height: 360,
+      open: () => new Promise((res) => { resolveFirst = res; }),
+      control: async () => {}, close, setView: async (p) => p,
+    });
+    const second = new NativePlayerElement(file, {
+      width: 640, height: 360, open: async () => info, control: async () => {}, close, setView: async (p) => p,
+    });
+    const opening = first.open();
+    first.close();
+    await second.open();
+    resolveFirst!(info);
+    await expect(opening).rejects.toThrow(/closed/);
+    expect(close).not.toHaveBeenCalled();
+    expect(second.streamUrl).toBe("u");
+  });
 });
diff --git a/src/lib/insta360/nativePlayer.ts b/src/lib/insta360/nativePlayer.ts
index 2829563d..629c72b6 100644
--- a/src/lib/insta360/nativePlayer.ts
+++ b/src/lib/insta360/nativePlayer.ts
@@ -64,6 +64,17 @@ export interface NativePlayerOptions {
 
 const SEEK_WATCHDOG_MS = 600;
 
+/**
+ * The shell runs ONE native player and `insta360_player_close` carries no
+ * player id, so a superseded element's late close (its `close()` after a newer
+ * element opened, or an open that resolved after it was closed) would kill
+ * whichever stream is live now. Track which element last opened the player
+ * and let only that one release it. Keyed by the close command so injected
+ * test doubles each get their own slot; in the app every element shares the
+ * real one.
+ */
+const playerOwners = new WeakMap<object, NativePlayerElement>();
+
 /**
  * One native player session over one camera recording. `open()` starts the
  * stream; `close()` (or opening another) stops it. Extends `EventTarget` so
@@ -189,9 +200,11 @@ export class NativePlayerElement extends EventTarget implements VideoSurface {
       quality: this.opts.quality,
       muted: this.opts.muted,
     };
+    // Opening replaces any earlier player in the shell, so ownership moves now.
+    playerOwners.set(this.ipc.close, this);
     const info = await this.ipc.open(request, (e) => this.onEvent(e));
     if (this.closed) {
-      void this.ipc.close();
+      this.releaseNativePlayer();
       throw new Error("player closed while opening");
     }
     this.info = info;
@@ -207,7 +220,7 @@ export class NativePlayerElement extends EventTarget implements VideoSurface {
     if (this.closed) return;
     this.closed = true;
     this.clearSeekTimer();
-    if (this.info) void this.ipc.close();
+    if (this.info) this.releaseNativePlayer();
     this.info = null;
     this.clock.setPlaying(false, this.now());
   }
@@ -222,6 +235,13 @@ export class NativePlayerElement extends EventTarget implements VideoSurface {
 
   // ── internals ───────────────────────────────────────────────────────────
 
+  /** Close the shell's player — only while this element is the one that owns it. */
+  private releaseNativePlayer(): void {
+    if (playerOwners.get(this.ipc.close) !== this) return;
+    playerOwners.delete(this.ipc.close);
+    void this.ipc.close();
+  }
+
   private seekTo(sec: number, precise: boolean): void {
     if (this.closed || !this.info) return;
     const positionMs = Math.max(0, Math.round(sec * 1000));
@@ -281,6 +301,7 @@ export class NativePlayerElement extends EventTarget implements VideoSurface {
         this.dispatchEvent(new Event("error"));
         break;
       case "closed":
+        if (playerOwners.get(this.ipc.close) === this) playerOwners.delete(this.ipc.close);
         this.closed = true;
         this.info = null;
         this.clearSeekTimer();
diff --git a/src/lib/nativeUnavailable.test.ts b/src/lib/nativeUnavailable.test.ts
new file mode 100644
index 00000000..05ea6a63
--- /dev/null
+++ b/src/lib/nativeUnavailable.test.ts
@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import { isNativeFeatureUnavailable } from "./nativeUnavailable";
+
+describe("isNativeFeatureUnavailable", () => {
+  it("accepts the shell's unsupported: sentinel, as a string or an Error", () => {
+    expect(isNativeFeatureUnavailable("unsupported: native video export is not supported on this platform yet")).toBe(true);
+    expect(isNativeFeatureUnavailable(new Error("unsupported: no Insta360 SDK in this build"))).toBe(true);
+  });
+
+  it("accepts Tauri's missing-command and ACL rejections from an older shell", () => {
+    expect(isNativeFeatureUnavailable("Command video_export_begin not found")).toBe(true);
+    expect(isNativeFeatureUnavailable(new Error("Command video_store_list not found"))).toBe(true);
+    expect(isNativeFeatureUnavailable("unknown command insta360_sdk_info")).toBe(true);
+    expect(isNativeFeatureUnavailable("insta360_player_open not allowed. Permissions associated with this command: none")).toBe(true);
+  });
+
+  it("rejects errors from a command that ran — those must be reported", () => {
+    for (const msg of [
+      "no stored video for key abc",
+      "file not found",
+      "unknown error",
+      "camera not found on the network",
+      "device unreachable: not found",
+      "storage write is not allowed while recording",
+      "transcode failed: unsupported: codec", // the sentinel only counts as a prefix
+    ]) {
+      expect(isNativeFeatureUnavailable(msg), msg).toBe(false);
+    }
+  });
+});
diff --git a/src/lib/nativeUnavailable.ts b/src/lib/nativeUnavailable.ts
new file mode 100644
index 00000000..9129d61d
--- /dev/null
+++ b/src/lib/nativeUnavailable.ts
@@ -0,0 +1,23 @@
+/**
+ * "This shell can't do that" — the one classifier every optional native
+ * (LapWing shell) feature uses to decide between falling back quietly and
+ * surfacing an error.
+ *
+ * Two shapes mean unavailable:
+ * - the shell's own sentinel: a rejection prefixed `unsupported:` (a desktop
+ *   stub, or an Android build without the feature's SDK);
+ * - Tauri refusing the invoke because the command doesn't exist in this
+ *   (older) shell — `Command <name> not found`, an `unknown command`, or an
+ *   ACL denial (`<name> not allowed…`).
+ *
+ * Deliberately narrow: a command that ran and failed (`no stored video for
+ * key …`, `file not found`, `unknown error`) is a real error the caller must
+ * report, not a reason to silently take another path.
+ */
+
+const MISSING_COMMAND = /\bcommand\s+\S+\s+not\s+found\b|\bunknown\s+command\b|^\S+\s+not\s+allowed\b/i;
+
+export function isNativeFeatureUnavailable(err: unknown): boolean {
+  const msg = err instanceof Error ? err.message : String(err);
+  return msg.startsWith("unsupported:") || MISSING_COMMAND.test(msg);
+}
diff --git a/src/lib/nativeVideoExport.ts b/src/lib/nativeVideoExport.ts
index d32b29e1..8a692ebf 100644
--- a/src/lib/nativeVideoExport.ts
+++ b/src/lib/nativeVideoExport.ts
@@ -25,6 +25,7 @@
 import { api } from "@/lib/loggers/native/ipc";
 import { blobToBase64, NATIVE_CHUNK_BYTES } from "@/lib/nativeBytes";
 import { isNativeApp } from "@/lib/platform";
+import { isNativeFeatureUnavailable } from "@/lib/nativeUnavailable";
 import {
   renderOverlaysToCanvas,
   DEFAULT_OVERLAY_LABELS,
@@ -47,13 +48,6 @@ export interface NativeExportController {
   cancel: () => void;
 }
 
-/** True for the errors that mean "this shell can't do native export" — the
- * desktop stub's sentinel, or a shell predating the command. */
-function isUnavailable(err: unknown): boolean {
-  const msg = String(err);
-  return msg.startsWith("unsupported:") || /unknown|not found|not allowed/i.test(msg);
-}
-
 /**
  * Try to run the export natively. Resolves `null` when the native pipeline is
  * unavailable (caller falls back to the in-WebView exporter — nothing has been
@@ -113,12 +107,12 @@ export async function startNativeVideoExport(
         params: useStoredSource ? { ...baseParams, sourceKey: source.nativeSourceKey } : baseParams,
       });
     } catch (err) {
-      if (!useStoredSource || isUnavailable(err)) throw err;
+      if (!useStoredSource || isNativeFeatureUnavailable(err)) throw err;
       useStoredSource = false;
       jobId = await invoke<string>("video_export_begin", { params: baseParams });
     }
   } catch (err) {
-    if (isUnavailable(err)) return null;
+    if (isNativeFeatureUnavailable(err)) return null;
     callbacks.onError(String(err));
     return { cancel: () => {} };
   }
diff --git a/src/lib/nativeVideoStore.ts b/src/lib/nativeVideoStore.ts
index ef4eabbc..fb770fb9 100644
--- a/src/lib/nativeVideoStore.ts
+++ b/src/lib/nativeVideoStore.ts
@@ -25,6 +25,8 @@
 import { api } from "@/lib/loggers/native/ipc";
 import { blobToBase64, NATIVE_CHUNK_BYTES } from "@/lib/nativeBytes";
 import { isNativeApp } from "@/lib/platform";
+import { isNativeFeatureUnavailable } from "@/lib/nativeUnavailable";
+import { NATIVE_VIDEO_STORE_CHANGED, type NativeVideoStoreChangedDetail } from "@/lib/nativeVideoStoreEvents";
 
 export interface NativeStoredVideo {
   key: string;
@@ -52,15 +54,7 @@ export interface NativeStoredVideoEntry extends StoredVideoInfo {
   storedAtMs?: number;
 }
 
-/**
- * Fired on `window` after a stored video is removed or the store is cleared,
- * so a session that is playing (or exporting) from the deleted copy can react.
- * `removedKeys` is `null` when everything went.
- */
-export const NATIVE_VIDEO_STORE_CHANGED = "native-video-store-changed";
-export interface NativeVideoStoreChangedDetail {
-  removedKeys: string[] | null;
-}
+export { NATIVE_VIDEO_STORE_CHANGED, type NativeVideoStoreChangedDetail } from "@/lib/nativeVideoStoreEvents";
 
 function announceStoreChange(removedKeys: string[] | null): void {
   if (typeof window === "undefined" || typeof CustomEvent === "undefined") return;
@@ -69,12 +63,6 @@ function announceStoreChange(removedKeys: string[] | null): void {
   );
 }
 
-/** The desktop stub's sentinel, or a shell predating the store commands. */
-function isUnavailable(err: unknown): boolean {
-  const msg = String(err);
-  return msg.startsWith("unsupported:") || /unknown|not found|not allowed/i.test(msg);
-}
-
 /** The session's remembered video, if the shell has one. */
 export async function getNativeStoredVideo(sessionFileName: string): Promise<NativeStoredVideo | null> {
   if (!isNativeApp()) return null;
@@ -84,7 +72,7 @@ export async function getNativeStoredVideo(sessionFileName: string): Promise<Nat
     if (!info) return null;
     return { ...info, url: convertFileSrc(info.path) };
   } catch (err) {
-    if (!isUnavailable(err)) console.warn("Native video store lookup failed:", err);
+    if (!isNativeFeatureUnavailable(err)) console.warn("Native video store lookup failed:", err);
     return null;
   }
 }
@@ -105,7 +93,7 @@ export async function storeNativeVideo(
   try {
     key = await invoke<string>("video_store_begin", { sessionFileName, fileName: file.name });
   } catch (err) {
-    if (isUnavailable(err)) return null;
+    if (isNativeFeatureUnavailable(err)) return null;
     throw err;
   }
   for (let offset = 0; offset < file.size; offset += NATIVE_CHUNK_BYTES) {
@@ -139,7 +127,7 @@ export async function listNativeStoredVideos(): Promise<NativeStoredVideoEntry[]
     const { invoke } = await api();
     return await invoke<NativeStoredVideoEntry[]>("video_store_list");
   } catch (err) {
-    if (!isUnavailable(err)) console.warn("Native video store listing failed:", err);
+    if (!isNativeFeatureUnavailable(err)) console.warn("Native video store listing failed:", err);
     return null;
   }
 }
diff --git a/src/lib/nativeVideoStoreEvents.ts b/src/lib/nativeVideoStoreEvents.ts
new file mode 100644
index 00000000..29a1795f
--- /dev/null
+++ b/src/lib/nativeVideoStoreEvents.ts
@@ -0,0 +1,13 @@
+/**
+ * The native video store's change event (plan 0024), split from
+ * `nativeVideoStore.ts` so eager listeners (`useVideoSync`) can subscribe
+ * without pulling the store's IPC bridge into the main chunk.
+ *
+ * Fired on `window` after a stored video is removed or the store is cleared,
+ * so a session that is playing (or exporting) from the deleted copy can react.
+ * `removedKeys` is `null` when everything went.
+ */
+export const NATIVE_VIDEO_STORE_CHANGED = "native-video-store-changed";
+export interface NativeVideoStoreChangedDetail {
+  removedKeys: string[] | null;
+}
diff --git a/src/lib/offlineReadiness.test.ts b/src/lib/offlineReadiness.test.ts
index 092726b6..a9d55891 100644
--- a/src/lib/offlineReadiness.test.ts
+++ b/src/lib/offlineReadiness.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { computeReadiness, readinessPercent } from "./offlineReadiness";
+import { computeReadiness, countCachedAssets, readinessPercent } from "./offlineReadiness";
 
 const base = {
   serviceWorkerSupported: true,
@@ -63,3 +63,22 @@ describe("readinessPercent", () => {
     expect(readinessPercent(-1, 4)).toBe(0);
   });
 });
+
+describe("countCachedAssets", () => {
+  const check = (cached: string[], throwing: string[] = []) => async (url: string) => {
+    if (throwing.includes(url)) throw new Error("storage evicted");
+    return cached.includes(url);
+  };
+
+  it("counts the assets the predicate reports as cached", async () => {
+    expect(await countCachedAssets(["/a", "/b", "/c"], check(["/a", "/c"]))).toBe(2);
+  });
+
+  it("treats a lookup that throws as a miss instead of failing the readout", async () => {
+    expect(await countCachedAssets(["/a", "/b"], check(["/a", "/b"], ["/b"]))).toBe(1);
+  });
+
+  it("is zero with nothing to check", async () => {
+    expect(await countCachedAssets([], check(["/a"]))).toBe(0);
+  });
+});
diff --git a/src/lib/offlineReadiness.ts b/src/lib/offlineReadiness.ts
index 0375360e..1288b0c4 100644
--- a/src/lib/offlineReadiness.ts
+++ b/src/lib/offlineReadiness.ts
@@ -56,3 +56,25 @@ export function readinessPercent(cached: number, total: number): number {
   if (total <= 0) return 100;
   return Math.min(100, Math.max(0, Math.round((cached / total) * 100)));
 }
+
+/**
+ * How many of `assets` the predicate reports as cached. The predicate decides
+ * what "cached" means (the deferred cache also checks the asset's revision);
+ * a lookup that throws (storage evicted mid-check, a quota error) counts as a
+ * miss rather than failing the whole readout.
+ */
+export async function countCachedAssets<T>(
+  assets: readonly T[],
+  isCached: (asset: T) => Promise<boolean>,
+): Promise<number> {
+  const hits = await Promise.all(
+    assets.map(async (asset) => {
+      try {
+        return await isCached(asset);
+      } catch {
+        return false;
+      }
+    }),
+  );
+  return hits.filter(Boolean).length;
+}
diff --git a/src/locales/de/drawer.json b/src/locales/de/drawer.json
index 9c551bc7..780035e6 100644
--- a/src/locales/de/drawer.json
+++ b/src/locales/de/drawer.json
@@ -146,6 +146,8 @@
     "title": "Setup-Verlauf",
     "openTitle": "Setup-Verlauf anzeigen",
     "loading": "Verlauf wird geladen…",
+    "loadFailed": "Der Verlauf dieses Setups konnte nicht geladen werden.",
+    "retry": "Erneut versuchen",
     "empty": "Noch kein Verlauf",
     "emptyHint": "Weise dieses Setup einer Sitzung zu, um den Verlauf aufzubauen.",
     "emptyUsedHint": "Noch keine Session hat dieses Setup verwendet. Wechsle zu Alle, um jede gespeicherte Revision zu sehen.",
@@ -158,9 +160,11 @@
     "rollbackTitle": "Auf dieses Setup zurücksetzen?",
     "rollbackBody": "{{setup}} wird auf das Setup vom {{date}} (#{{hash}}) zurückgesetzt. Deine aktuellen Änderungen bleiben {{days}} Tage im Verlauf.",
     "rollbackDone": "Auf #{{hash}} zurückgesetzt",
+    "rollbackFailed": "Zurücksetzen fehlgeschlagen – dein Setup wurde nicht geändert.",
     "duplicate": "Duplizieren",
     "duplicateName": "{{name}} (Kopie)",
     "duplicateDone": "{{name}} erstellt",
+    "duplicateFailed": "Diese Revision konnte nicht dupliziert werden.",
     "allKarts": "Alle Karts",
     "allCourses": "Alle Strecken",
     "original": "Original",
diff --git a/src/locales/de/landing.json b/src/locales/de/landing.json
index cb353e27..e42cc7ff 100644
--- a/src/locales/de/landing.json
+++ b/src/locales/de/landing.json
@@ -111,7 +111,7 @@
       },
       "gopro": {
         "name": "GoPro-Video (eingebettetes GPS)",
-        "body": "Lege ein GoPro-Video mit GPS ab (HERO5 oder neuer, GPS aktiviert) und die GPS-Spur, die die Kamera in die MP4 einbettet, wird zur Session — ganz ohne Logger. Nur die kleine Telemetriespur wird gelesen, nie das ganze Video; sie wird als Dove-Log gespeichert und das Video öffnet sich daneben bereits synchronisiert. Wähle alle Kapitel einer geteilten Aufnahme zusammen aus. Endungen: <code>.mp4</code>, <code>.mov</code>, <code>.360</code>"
+        "body": "Lege ein GoPro-Video mit GPS ab (HERO5 oder neuer, GPS aktiviert) und die GPS-Spur, die die Kamera in die MP4 einbettet, wird zur Session — ganz ohne Logger. Nur die kleine Telemetriespur wird gelesen, nie das ganze Video; sie wird als Dove-Log gespeichert und das Video öffnet sich daneben bereits synchronisiert. Wähle alle Kapitel einer geteilten Aufnahme zusammen aus. Endungen: <code>.mp4</code>, <code>.mov</code>, <code>.360</code> (experimentell)"
       },
       "xrk": {
         "name": "AiM XRK / XRZ (binär)",
diff --git a/src/locales/en/drawer.json b/src/locales/en/drawer.json
index 3805e000..82f3d826 100644
--- a/src/locales/en/drawer.json
+++ b/src/locales/en/drawer.json
@@ -145,6 +145,8 @@
     "title": "Setup History",
     "openTitle": "View setup history",
     "loading": "Loading history…",
+    "loadFailed": "Couldn't load this setup's history.",
+    "retry": "Retry",
     "empty": "No history yet",
     "emptyHint": "Assign this setup to a session to start building its history.",
     "emptyUsedHint": "No session has used this setup yet. Switch to All to see every saved revision.",
@@ -157,9 +159,11 @@
     "rollbackTitle": "Roll back to this setup?",
     "rollbackBody": "{{setup}} will be reset to the setup that ran on {{date}} (#{{hash}}). Your current edits stay in history for {{days}} days.",
     "rollbackDone": "Rolled back to #{{hash}}",
+    "rollbackFailed": "Rollback failed — your setup was not changed.",
     "duplicate": "Duplicate",
     "duplicateName": "{{name}} (copy)",
     "duplicateDone": "Created {{name}}",
+    "duplicateFailed": "Couldn't duplicate this revision.",
     "allKarts": "All karts",
     "allCourses": "All courses",
     "original": "Original",
diff --git a/src/locales/en/landing.json b/src/locales/en/landing.json
index 81ddc7f0..57582f60 100644
--- a/src/locales/en/landing.json
+++ b/src/locales/en/landing.json
@@ -190,7 +190,7 @@
       },
       "gopro": {
         "name": "GoPro Video (embedded GPS)",
-        "body": "Drop a GPS-tagged GoPro video (HERO5 and newer with GPS on) and the GPS track the camera embeds in the MP4 becomes the session — no logger needed. Only the small telemetry track is read, never the whole video; it is saved as a Dove log and the footage opens alongside it already synced. Select every chapter of a split recording together. Extensions: <code>.mp4</code>, <code>.mov</code>, <code>.360</code>"
+        "body": "Drop a GPS-tagged GoPro video (HERO5 and newer with GPS on) and the GPS track the camera embeds in the MP4 becomes the session — no logger needed. Only the small telemetry track is read, never the whole video; it is saved as a Dove log and the footage opens alongside it already synced. Select every chapter of a split recording together. Extensions: <code>.mp4</code>, <code>.mov</code>, <code>.360</code> (experimental)"
       },
       "xrk": {
         "name": "AiM XRK / XRZ (Binary)",
diff --git a/src/locales/es/drawer.json b/src/locales/es/drawer.json
index e4a74898..749fe199 100644
--- a/src/locales/es/drawer.json
+++ b/src/locales/es/drawer.json
@@ -146,6 +146,8 @@
     "title": "Historial de configuración",
     "openTitle": "Ver historial de configuración",
     "loading": "Cargando historial…",
+    "loadFailed": "No se pudo cargar el historial de esta configuración.",
+    "retry": "Reintentar",
     "empty": "Aún no hay historial",
     "emptyHint": "Asigna esta configuración a una sesión para empezar a crear su historial.",
     "emptyUsedHint": "Ninguna sesión ha usado esta configuración todavía. Cambia a Todas para ver cada revisión guardada.",
@@ -158,9 +160,11 @@
     "rollbackTitle": "¿Revertir a esta configuración?",
     "rollbackBody": "{{setup}} volverá a la configuración que se usó el {{date}} (#{{hash}}). Tus cambios actuales permanecen en el historial durante {{days}} días.",
     "rollbackDone": "Revertido a #{{hash}}",
+    "rollbackFailed": "No se pudo revertir: tu configuración no se ha modificado.",
     "duplicate": "Duplicar",
     "duplicateName": "{{name}} (copia)",
     "duplicateDone": "Se creó {{name}}",
+    "duplicateFailed": "No se pudo duplicar esta revisión.",
     "allKarts": "Todos los karts",
     "allCourses": "Todos los circuitos",
     "original": "Original",
diff --git a/src/locales/es/landing.json b/src/locales/es/landing.json
index b034fc44..e7b0b035 100644
--- a/src/locales/es/landing.json
+++ b/src/locales/es/landing.json
@@ -111,7 +111,7 @@
       },
       "gopro": {
         "name": "Vídeo GoPro (GPS integrado)",
-        "body": "Arrastra un vídeo GoPro con GPS (HERO5 o posterior con el GPS activado) y la pista GPS que la cámara incrusta en el MP4 se convierte en la sesión, sin necesidad de registrador. Solo se lee la pequeña pista de telemetría, nunca el vídeo completo; se guarda como registro Dove y las imágenes se abren junto a él ya sincronizadas. Selecciona juntos todos los capítulos de una grabación dividida. Extensiones: <code>.mp4</code>, <code>.mov</code>, <code>.360</code>"
+        "body": "Arrastra un vídeo GoPro con GPS (HERO5 o posterior con el GPS activado) y la pista GPS que la cámara incrusta en el MP4 se convierte en la sesión, sin necesidad de registrador. Solo se lee la pequeña pista de telemetría, nunca el vídeo completo; se guarda como registro Dove y las imágenes se abren junto a él ya sincronizadas. Selecciona juntos todos los capítulos de una grabación dividida. Extensiones: <code>.mp4</code>, <code>.mov</code>, <code>.360</code> (experimental)"
       },
       "xrk": {
         "name": "AiM XRK / XRZ (binario)",
diff --git a/src/locales/fr/drawer.json b/src/locales/fr/drawer.json
index fa78682c..52e5d43d 100644
--- a/src/locales/fr/drawer.json
+++ b/src/locales/fr/drawer.json
@@ -146,6 +146,8 @@
     "title": "Historique des réglages",
     "openTitle": "Voir l'historique des réglages",
     "loading": "Chargement de l'historique…",
+    "loadFailed": "Impossible de charger l'historique de ce réglage.",
+    "retry": "Réessayer",
     "empty": "Pas encore d'historique",
     "emptyHint": "Associez ce réglage à une session pour commencer à construire son historique.",
     "emptyUsedHint": "Aucune session n’a encore utilisé ce réglage. Passez sur Toutes pour voir chaque révision enregistrée.",
@@ -158,9 +160,11 @@
     "rollbackTitle": "Restaurer ce réglage ?",
     "rollbackBody": "{{setup}} sera remis au réglage utilisé le {{date}} (#{{hash}}). Vos modifications actuelles restent dans l’historique pendant {{days}} jours.",
     "rollbackDone": "Restauré vers #{{hash}}",
+    "rollbackFailed": "Échec de la restauration — votre réglage n'a pas été modifié.",
     "duplicate": "Dupliquer",
     "duplicateName": "{{name}} (copie)",
     "duplicateDone": "{{name}} créé",
+    "duplicateFailed": "Impossible de dupliquer cette révision.",
     "allKarts": "Tous les karts",
     "allCourses": "Tous les circuits",
     "original": "Original",
diff --git a/src/locales/fr/landing.json b/src/locales/fr/landing.json
index 0617fb64..b2d7d13e 100644
--- a/src/locales/fr/landing.json
+++ b/src/locales/fr/landing.json
@@ -111,7 +111,7 @@
       },
       "gopro": {
         "name": "Vidéo GoPro (GPS intégré)",
-        "body": "Déposez une vidéo GoPro géolocalisée (HERO5 ou plus récente, GPS activé) et la trace GPS que la caméra intègre au MP4 devient la session, sans enregistreur. Seule la petite piste de télémétrie est lue, jamais la vidéo entière ; elle est enregistrée comme journal Dove et la vidéo s'ouvre à côté, déjà synchronisée. Sélectionnez ensemble tous les chapitres d'un enregistrement découpé. Extensions : <code>.mp4</code>, <code>.mov</code>, <code>.360</code>"
+        "body": "Déposez une vidéo GoPro géolocalisée (HERO5 ou plus récente, GPS activé) et la trace GPS que la caméra intègre au MP4 devient la session, sans enregistreur. Seule la petite piste de télémétrie est lue, jamais la vidéo entière ; elle est enregistrée comme journal Dove et la vidéo s'ouvre à côté, déjà synchronisée. Sélectionnez ensemble tous les chapitres d'un enregistrement découpé. Extensions : <code>.mp4</code>, <code>.mov</code>, <code>.360</code> (expérimental)"
       },
       "xrk": {
         "name": "AiM XRK / XRZ (binaire)",
diff --git a/src/locales/it/drawer.json b/src/locales/it/drawer.json
index 66a0b2f4..b4510d3d 100644
--- a/src/locales/it/drawer.json
+++ b/src/locales/it/drawer.json
@@ -146,6 +146,8 @@
     "title": "Cronologia assetto",
     "openTitle": "Visualizza cronologia assetto",
     "loading": "Caricamento cronologia…",
+    "loadFailed": "Impossibile caricare la cronologia di questo assetto.",
+    "retry": "Riprova",
     "empty": "Nessuna cronologia",
     "emptyHint": "Assegna questo assetto a una sessione per iniziare a creare la sua cronologia.",
     "emptyUsedHint": "Nessuna sessione ha ancora usato questo assetto. Passa a Tutte per vedere ogni revisione salvata.",
@@ -158,9 +160,11 @@
     "rollbackTitle": "Ripristinare questo assetto?",
     "rollbackBody": "{{setup}} tornerà all’assetto usato il {{date}} (#{{hash}}). Le modifiche attuali restano nella cronologia per {{days}} giorni.",
     "rollbackDone": "Ripristinato a #{{hash}}",
+    "rollbackFailed": "Ripristino non riuscito: l'assetto non è stato modificato.",
     "duplicate": "Duplica",
     "duplicateName": "{{name}} (copia)",
     "duplicateDone": "{{name}} creato",
+    "duplicateFailed": "Impossibile duplicare questa revisione.",
     "allKarts": "Tutti i kart",
     "allCourses": "Tutti i circuiti",
     "original": "Originale",
diff --git a/src/locales/it/landing.json b/src/locales/it/landing.json
index 6fd4732a..4f0e2b7b 100644
--- a/src/locales/it/landing.json
+++ b/src/locales/it/landing.json
@@ -111,7 +111,7 @@
       },
       "gopro": {
         "name": "Video GoPro (GPS integrato)",
-        "body": "Trascina un video GoPro con GPS (HERO5 o successiva, GPS attivo) e la traccia GPS che la camera incorpora nell'MP4 diventa la sessione, senza alcun logger. Viene letta solo la piccola traccia di telemetria, mai l'intero video; viene salvata come log Dove e il filmato si apre accanto già sincronizzato. Seleziona insieme tutti i capitoli di una registrazione divisa. Estensioni: <code>.mp4</code>, <code>.mov</code>, <code>.360</code>"
+        "body": "Trascina un video GoPro con GPS (HERO5 o successiva, GPS attivo) e la traccia GPS che la camera incorpora nell'MP4 diventa la sessione, senza alcun logger. Viene letta solo la piccola traccia di telemetria, mai l'intero video; viene salvata come log Dove e il filmato si apre accanto già sincronizzato. Seleziona insieme tutti i capitoli di una registrazione divisa. Estensioni: <code>.mp4</code>, <code>.mov</code>, <code>.360</code> (sperimentale)"
       },
       "xrk": {
         "name": "AiM XRK / XRZ (binario)",
diff --git a/src/locales/ja/drawer.json b/src/locales/ja/drawer.json
index fee6f8d6..3f53440f 100644
--- a/src/locales/ja/drawer.json
+++ b/src/locales/ja/drawer.json
@@ -146,6 +146,8 @@
     "title": "セットアップ履歴",
     "openTitle": "セットアップ履歴を表示",
     "loading": "履歴を読み込み中…",
+    "loadFailed": "このセットアップの履歴を読み込めませんでした。",
+    "retry": "再試行",
     "empty": "まだ履歴がありません",
     "emptyHint": "このセットアップをセッションに割り当てると履歴の作成が始まります。",
     "emptyUsedHint": "このセットアップを使用したセッションはまだありません。「すべて」に切り替えると保存済みのすべてのリビジョンを表示できます。",
@@ -158,9 +160,11 @@
     "rollbackTitle": "このセットアップにロールバックしますか？",
     "rollbackBody": "{{setup}} は {{date}} に使用したセットアップ（#{{hash}}）に戻ります。現在の編集内容は {{days}} 日間履歴に残ります。",
     "rollbackDone": "#{{hash}} にロールバックしました",
+    "rollbackFailed": "ロールバックに失敗しました。セットアップは変更されていません。",
     "duplicate": "複製",
     "duplicateName": "{{name}}（コピー）",
     "duplicateDone": "{{name}} を作成しました",
+    "duplicateFailed": "このリビジョンを複製できませんでした。",
     "allKarts": "すべてのカート",
     "allCourses": "すべてのコース",
     "original": "オリジナル",
diff --git a/src/locales/ja/landing.json b/src/locales/ja/landing.json
index d4f9c669..00b4a221 100644
--- a/src/locales/ja/landing.json
+++ b/src/locales/ja/landing.json
@@ -111,7 +111,7 @@
       },
       "gopro": {
         "name": "GoPro動画（内蔵GPS）",
-        "body": "GPS付きのGoPro動画（HERO5以降、GPS有効）をドロップすると、カメラがMP4に埋め込んだGPSトラックがそのままセッションになります。ロガーは不要です。読み込むのは小さなテレメトリトラックだけで、動画全体は読み込みません。Doveログとして保存され、映像は同期済みの状態で並んで開きます。分割された録画は全チャプターをまとめて選択してください。拡張子: <code>.mp4</code>, <code>.mov</code>, <code>.360</code>"
+        "body": "GPS付きのGoPro動画（HERO5以降、GPS有効）をドロップすると、カメラがMP4に埋め込んだGPSトラックがそのままセッションになります。ロガーは不要です。読み込むのは小さなテレメトリトラックだけで、動画全体は読み込みません。Doveログとして保存され、映像は同期済みの状態で並んで開きます。分割された録画は全チャプターをまとめて選択してください。拡張子: <code>.mp4</code>, <code>.mov</code>, <code>.360</code>（試験的）"
       },
       "xrk": {
         "name": "AiM XRK / XRZ（バイナリ）",
diff --git a/src/locales/pt-BR/drawer.json b/src/locales/pt-BR/drawer.json
index 6c8b99b6..33ea8138 100644
--- a/src/locales/pt-BR/drawer.json
+++ b/src/locales/pt-BR/drawer.json
@@ -146,6 +146,8 @@
     "title": "Histórico de configuração",
     "openTitle": "Ver histórico de configuração",
     "loading": "Carregando histórico…",
+    "loadFailed": "Não foi possível carregar o histórico desta configuração.",
+    "retry": "Tentar novamente",
     "empty": "Ainda não há histórico",
     "emptyHint": "Atribua esta configuração a uma sessão para começar a criar o histórico.",
     "emptyUsedHint": "Nenhuma sessão usou esta configuração ainda. Mude para Todas para ver cada revisão salva.",
@@ -158,9 +160,11 @@
     "rollbackTitle": "Reverter para esta configuração?",
     "rollbackBody": "{{setup}} será redefinida para a configuração usada em {{date}} (#{{hash}}). Suas edições atuais permanecem no histórico por {{days}} dias.",
     "rollbackDone": "Revertido para #{{hash}}",
+    "rollbackFailed": "Falha ao reverter — sua configuração não foi alterada.",
     "duplicate": "Duplicar",
     "duplicateName": "{{name}} (cópia)",
     "duplicateDone": "{{name}} criado",
+    "duplicateFailed": "Não foi possível duplicar esta revisão.",
     "allKarts": "Todos os karts",
     "allCourses": "Todas as pistas",
     "original": "Original",
diff --git a/src/locales/pt-BR/landing.json b/src/locales/pt-BR/landing.json
index cdb2168e..76d04e2d 100644
--- a/src/locales/pt-BR/landing.json
+++ b/src/locales/pt-BR/landing.json
@@ -111,7 +111,7 @@
       },
       "gopro": {
         "name": "Vídeo GoPro (GPS embutido)",
-        "body": "Solte um vídeo GoPro com GPS (HERO5 ou mais nova, com GPS ligado) e a trilha GPS que a câmera embute no MP4 vira a sessão — sem precisar de logger. Só a pequena trilha de telemetria é lida, nunca o vídeo inteiro; ela é salva como log Dove e a filmagem abre ao lado já sincronizada. Selecione juntos todos os capítulos de uma gravação dividida. Extensões: <code>.mp4</code>, <code>.mov</code>, <code>.360</code>"
+        "body": "Solte um vídeo GoPro com GPS (HERO5 ou mais nova, com GPS ligado) e a trilha GPS que a câmera embute no MP4 vira a sessão — sem precisar de logger. Só a pequena trilha de telemetria é lida, nunca o vídeo inteiro; ela é salva como log Dove e a filmagem abre ao lado já sincronizada. Selecione juntos todos os capítulos de uma gravação dividida. Extensões: <code>.mp4</code>, <code>.mov</code>, <code>.360</code> (experimental)"
       },
       "xrk": {
         "name": "AiM XRK / XRZ (binário)",
diff --git a/vite.config.ts b/vite.config.ts
index 71145079..1328b9dd 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -6,6 +6,7 @@ import { createHash } from "crypto";
 import { execSync } from "child_process";
 import { VitePWA } from "vite-plugin-pwa";
 import { resolveBranchBackend } from "./scripts/resolveSupabaseBranch";
+import { DEFERRED_ASSET_DIRS, deferredAssetPathPattern, sameOriginPathMatcher } from "./scripts/deferredAssets";
 
 // Build-time version metadata for the footer "what changed" stamp. The app
 // version comes from package.json; the commit hash + build date are baked in at
@@ -98,9 +99,8 @@ function externalPluginsLoader(candidates: string[]): Plugin {
 // boot: they are runtime-cached instead (see `runtimeCaching` below) and warmed
 // in the background once the worker is active (src/lib/offlineWarmup.ts), so
 // they still work offline without being able to take the whole install down.
-// One source of truth — the globs feed `globIgnores`, the runtime-cache route
-// and the emitted manifest alike.
-const DEFERRED_ASSET_DIRS = ["samples", "loggers"] as const;
+// One source of truth — DEFERRED_ASSET_DIRS (scripts/deferredAssets.ts) feeds
+// `globIgnores`, the runtime-cache route and the emitted manifest alike.
 const DEFERRED_ASSET_GLOBS = DEFERRED_ASSET_DIRS.map((dir) => `${dir}/**`);
 
 /** Where the client reads the list of deferred assets to warm. */
@@ -393,7 +393,7 @@ export default defineConfig(async ({ mode }) => {
           // running tab fetches uncached to detect a newer deploy (see versionCheck.ts).
           // The deferred directories are excluded so a slow or dropped connection
           // can't abort the whole install; they are runtime-cached and warmed
-          // afterwards instead. See DEFERRED_ASSET_DIRS above.
+          // afterwards instead. See DEFERRED_ASSET_DIRS (scripts/deferredAssets.ts).
           // og-image.png is only ever fetched by link-preview crawlers — no reason
           // to ship it in every offline install.
           // vendor-posthog: only analytics users ever load it (plan 0030), so it is
@@ -406,12 +406,11 @@ export default defineConfig(async ({ mode }) => {
               // DEFERRED_ASSET_DIRS). CacheFirst so that once warmed they are
               // served offline exactly as if precached — the difference is only
               // that failing to fetch one can no longer abort the install.
-              // The pattern is inlined rather than built from the constant
-              // because workbox-build serializes this function into the worker,
-              // where nothing from this module's scope exists. `sameOrigin` is
-              // supplied by Workbox's route matcher.
-              urlPattern: ({ url, sameOrigin }: { url: URL; sameOrigin: boolean }) =>
-                sameOrigin && /^\/(?:samples|loggers)\//.test(url.pathname),
+              // workbox-build serializes this callback into the worker, where
+              // nothing from this module's scope exists, so the matcher bakes the
+              // pattern derived from DEFERRED_ASSET_DIRS into its source text.
+              // `sameOrigin` is supplied by Workbox's route matcher.
+              urlPattern: sameOriginPathMatcher(deferredAssetPathPattern(DEFERRED_ASSET_DIRS)),
               handler: "CacheFirst",
               options: {
                 // No ExpirationPlugin here on purpose: the warm-up writes these