diff --git a/photon-client/src/App.vue b/photon-client/src/App.vue
index edcdc365c1..f32f080e5b 100644
--- a/photon-client/src/App.vue
+++ b/photon-client/src/App.vue
@@ -7,6 +7,7 @@ import { inject, onBeforeMount } from "vue";
 import PhotonSidebar from "@/components/app/photon-sidebar.vue";
 import PhotonLogView from "@/components/app/photon-log-view.vue";
 import PhotonErrorSnackbar from "@/components/app/photon-error-snackbar.vue";
+import ReplayBanner from "@/components/common/ReplayBanner.vue";
 import { useTheme } from "vuetify";
 import { restoreThemeConfig } from "@/lib/ThemeManager";
 
@@ -63,6 +64,7 @@ onBeforeMount(() => {
 <template>
   <v-app>
     <photon-sidebar />
+    <replay-banner />
     <v-main>
       <v-container class="main-container" fluid fill-height>
         <v-layout>
diff --git a/photon-client/src/components/common/ReplayBanner.vue b/photon-client/src/components/common/ReplayBanner.vue
new file mode 100644
index 0000000000..1ee827962c
--- /dev/null
+++ b/photon-client/src/components/common/ReplayBanner.vue
@@ -0,0 +1,113 @@
+<script setup lang="ts">
+import { computed } from "vue";
+import { axiosPost } from "@/lib/PhotonUtils";
+import { useCameraSettingsStore } from "@/stores/settings/CameraSettingsStore";
+import { useReplayStatus } from "@/composables/useReplayStatus";
+
+const { active } = useReplayStatus();
+const cameraStore = useCameraSettingsStore();
+
+interface BannerRow {
+  cameraUniqueName: string;
+  nickname: string;
+  recordingName: string;
+  currentFrame: number;
+  totalFrames: number;
+  progress: number;
+}
+
+const ROW_HEIGHT_PX = 64;
+
+const rows = computed<BannerRow[]>(() =>
+  active.value.map((entry) => {
+    const camera = cameraStore.cameras[entry.cameraUniqueName];
+    const total = entry.totalFrames > 0 ? entry.totalFrames : 1;
+    return {
+      cameraUniqueName: entry.cameraUniqueName,
+      nickname: camera?.nickname ?? entry.cameraUniqueName,
+      recordingName: entry.recordingName,
+      currentFrame: entry.currentFrame,
+      totalFrames: entry.totalFrames,
+      progress: Math.min(100, Math.round((entry.currentFrame / total) * 100))
+    };
+  })
+);
+
+const cancelReplay = (cameraUniqueName: string) => {
+  void axiosPost("/recordings/replay/cancel", "cancel replay on " + cameraUniqueName, { cameraUniqueName });
+};
+</script>
+
+<template>
+  <v-app-bar
+    v-if="rows.length > 0"
+    location="top"
+    :height="rows.length * ROW_HEIGHT_PX"
+    color="info"
+    flat
+    role="status"
+    aria-live="polite"
+  >
+    <div class="replay-banner-stack">
+      <div v-for="row in rows" :key="row.cameraUniqueName" class="replay-banner-row">
+        <div class="replay-banner-content">
+          <div class="replay-banner-text">
+            <strong>Replaying</strong>
+            <span class="replay-banner-recording">{{ row.recordingName }}</span>
+            <span>on</span>
+            <strong>{{ row.nickname }}</strong>
+            <span class="replay-banner-counter">— frame {{ row.currentFrame }} / {{ row.totalFrames }}</span>
+          </div>
+          <v-btn size="small" color="error" variant="flat" @click="cancelReplay(row.cameraUniqueName)">
+            <v-icon start>mdi-stop</v-icon>
+            Cancel
+          </v-btn>
+        </div>
+        <v-progress-linear :model-value="row.progress" color="white" bg-color="rgba(255, 255, 255, 0.2)" height="3" />
+      </div>
+    </div>
+  </v-app-bar>
+</template>
+
+<style scoped>
+.replay-banner-stack {
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+}
+
+.replay-banner-row {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  gap: 0.25rem;
+  padding: 0.5rem 1rem;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.12);
+}
+
+.replay-banner-row:last-child {
+  border-bottom: none;
+}
+
+.replay-banner-content {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+}
+
+.replay-banner-text {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.4rem;
+  align-items: baseline;
+}
+
+.replay-banner-recording {
+  font-family: monospace;
+}
+
+.replay-banner-counter {
+  opacity: 0.85;
+}
+</style>
diff --git a/photon-client/src/components/settings/RecordingsCard.vue b/photon-client/src/components/settings/RecordingsCard.vue
new file mode 100644
index 0000000000..8c704ff574
--- /dev/null
+++ b/photon-client/src/components/settings/RecordingsCard.vue
@@ -0,0 +1,519 @@
+<script setup lang="ts">
+import axios from "axios";
+import { ref, inject, computed, watch } from "vue";
+import { useTheme } from "vuetify";
+import { axiosPost } from "@/lib/PhotonUtils";
+import { useCameraSettingsStore } from "@/stores/settings/CameraSettingsStore";
+import PvSelect from "@/components/common/pv-select.vue";
+import PvDeleteModal from "@/components/common/pv-delete-modal.vue";
+import PhotonCameraStream from "@/components/app/photon-camera-stream.vue";
+import { useSettingsStore } from "@/stores/settings/GeneralSettingsStore";
+import { useReplayStatus, type ActiveReplay } from "@/composables/useReplayStatus";
+import type { UiCameraConfiguration } from "@/types/SettingTypes";
+
+interface ResultInfo {
+  hash: string;
+  sizeBytes: number;
+  resultCount: number;
+  pipelineType: string;
+  tssActiveAtRecord: boolean;
+  mtimeMillis: number;
+}
+
+const AUTO_DOWNLOAD_KEY = "photonvision.recordings.autoDownloadResults";
+
+const theme = useTheme();
+
+const address = inject<string>("backendHost");
+
+// Initialize selected recordings for each camera. The computed below seeds an entry for
+// every camera with at least one recording before the table renders, so the lookup at v-model
+// time is always a valid string — declaring undefined-in-value just produced a v-model type
+// mismatch against pv-select's `T extends string | number`.
+const selectedRecordings = ref<Record<string, string>>({});
+
+const camerasWithRecordings = computed(() => {
+  const cameras = useCameraSettingsStore().camerasWithRecordings;
+  // Initialize selectedRecordings for any new cameras
+  cameras.forEach((camera) => {
+    if (!(camera.uniqueName in selectedRecordings.value) && camera.recordings.length > 0) {
+      selectedRecordings.value[camera.uniqueName] = camera.recordings[0];
+    }
+  });
+  return cameras;
+});
+
+const { active: activeReplays } = useReplayStatus();
+const isReplayingHere = (cameraUniqueName: string) =>
+  activeReplays.value.some((r) => r.cameraUniqueName === cameraUniqueName);
+
+const resultsKey = (cameraUniqueName: string, recording: string) => `${cameraUniqueName}::${recording}`;
+const expandedResults = ref<Record<string, boolean>>({});
+const resultsCache = ref<Record<string, ResultInfo[]>>({});
+const resultsLoading = ref<Record<string, boolean>>({});
+
+const autoDownloadResults = ref<boolean>(window.localStorage.getItem(AUTO_DOWNLOAD_KEY) !== "false");
+watch(autoDownloadResults, (v) => window.localStorage.setItem(AUTO_DOWNLOAD_KEY, String(v)));
+
+const fetchResults = async (cameraUniqueName: string, recording: string): Promise<ResultInfo[]> => {
+  const key = resultsKey(cameraUniqueName, recording);
+  resultsLoading.value[key] = true;
+  try {
+    const res = await axios.get<ResultInfo[]>("/recordings/results", {
+      params: { camera: cameraUniqueName, recording }
+    });
+    const sorted = [...res.data].sort((a, b) => b.mtimeMillis - a.mtimeMillis);
+    resultsCache.value[key] = sorted;
+    return sorted;
+  } catch {
+    resultsCache.value[key] = [];
+    return [];
+  } finally {
+    resultsLoading.value[key] = false;
+  }
+};
+
+const toggleResults = (camera: UiCameraConfiguration) => {
+  const recording = selectedRecordings.value[camera.uniqueName];
+  if (!recording) return;
+  const key = resultsKey(camera.uniqueName, recording);
+  const next = !expandedResults.value[key];
+  expandedResults.value[key] = next;
+  // Re-fetch on every open so the dropdown reflects results created since the
+  // last expand (e.g. another replay landed while this row was collapsed).
+  if (next) void fetchResults(camera.uniqueName, recording);
+};
+
+const resultDownloadHref = (cameraUniqueName: string, recording: string, hash: string) =>
+  `http://${address}/api/recordings/result?camera=${encodeURIComponent(cameraUniqueName)}&recording=${encodeURIComponent(recording)}&hash=${encodeURIComponent(hash)}`;
+
+const triggerDownload = (href: string) => {
+  const link = document.createElement("a");
+  link.href = href;
+  // Server sets Content-Disposition; no need to set link.download.
+  link.click();
+};
+
+const previousActive = ref<ActiveReplay[]>([]);
+watch(
+  activeReplays,
+  (current) => {
+    const ended = previousActive.value.filter(
+      (prev) => !current.some((c) => c.cameraUniqueName === prev.cameraUniqueName)
+    );
+    previousActive.value = [...current];
+    if (!autoDownloadResults.value) return;
+    for (const entry of ended) {
+      void (async () => {
+        const list = await fetchResults(entry.cameraUniqueName, entry.recordingName);
+        if (list.length === 0) return;
+        triggerDownload(resultDownloadHref(entry.cameraUniqueName, entry.recordingName, list[0].hash));
+      })();
+    }
+  },
+  { deep: true }
+);
+
+const confirmDeleteDialog = ref({ show: false, recordings: [] as string[], cameraUniqueName: "" });
+
+const deleteRecordings = (recordingsToDelete: string[], cameraUniqueName: string) => {
+  void axiosPost("/recordings/delete", "delete " + recordingsToDelete.join(", "), {
+    recordings: recordingsToDelete,
+    cameraUniqueName: cameraUniqueName
+  });
+};
+
+const showNukeDialog = ref(false);
+const nukeRecordings = () => {
+  void axiosPost("/recordings/nuke", "clear and reset all recordings");
+};
+
+const downloadIndividualRecording = (camera: UiCameraConfiguration) => {
+  const recording = selectedRecordings.value[camera.uniqueName];
+  const link = document.createElement("a");
+  link.href = `http://${address}/api/recordings/exportIndividual?recording=${encodeURIComponent(recording ?? "")}&camera=${encodeURIComponent(camera.uniqueName)}`;
+  link.download = `${camera.nickname}_${recording}_recording.zip`;
+  link.click();
+};
+
+const replayRecording = (camera: UiCameraConfiguration) => {
+  const recording = selectedRecordings.value[camera.uniqueName];
+  if (!recording) return;
+  void axiosPost("/recordings/replay", "replay " + recording + " on " + camera.nickname, {
+    cameraUniqueName: camera.uniqueName,
+    recording
+  });
+};
+
+const downloadCameraRecordings = (camera: UiCameraConfiguration) => {
+  const link = document.createElement("a");
+  link.href = `http://${address}/api/recordings/exportCamera?camera=${encodeURIComponent(camera.uniqueName)}`;
+  link.download = `${camera.nickname}_recordings.zip`;
+  link.click();
+};
+
+const downloadAllRecordings = () => {
+  const link = document.createElement("a");
+  link.href = `http://${address}/api/recordings/export`;
+  link.download = "photonvision-recordings-export.zip";
+  link.click();
+};
+</script>
+
+<template>
+  <v-card class="mb-3" color="surface">
+    <v-card-title>Recordings</v-card-title>
+    <div class="pa-5 pt-0">
+      <pv-select
+        v-model="useSettingsStore().general.recordingStrategy"
+        label="Recording Strategy"
+        :items="useSettingsStore().general.supportedRecordingStrategies"
+        @update:modelValue="(args) => useSettingsStore().setRecordingStrategy(String(args ?? ''))"
+      />
+      <div v-if="camerasWithRecordings.length > 0">
+        <v-row>
+          <v-col cols="12" sm="6">
+            <v-btn
+              color="buttonPassive"
+              :variant="theme.global.name.value === 'LightTheme' ? 'elevated' : 'outlined'"
+              @click="downloadAllRecordings()"
+            >
+              <v-icon start class="open-icon"> mdi-export </v-icon>
+              <span class="open-label">Export Recordings</span>
+            </v-btn>
+          </v-col>
+          <v-col cols="12" sm="6">
+            <v-btn
+              color="error"
+              :variant="theme.global.name.value === 'LightTheme' ? 'elevated' : 'outlined'"
+              @click="() => (showNukeDialog = true)"
+            >
+              <v-icon left class="open-icon"> mdi-trash </v-icon>
+              <span class="open-label">Clear all recordings</span>
+            </v-btn>
+          </v-col>
+        </v-row>
+        <v-row>
+          <v-col cols="12">
+            <v-checkbox
+              v-model="autoDownloadResults"
+              label="Auto-download results when replay finishes"
+              density="compact"
+              hide-details
+            />
+          </v-col>
+        </v-row>
+        <v-row>
+          <v-col cols="">
+            <v-table fixed-header height="100%" density="compact" dark>
+              <thead style="font-size: 1.25rem">
+                <tr>
+                  <th>Camera</th>
+                  <th>Selected Recording</th>
+                  <th>Replay Selected</th>
+                  <th>Delete Selected</th>
+                  <th>Export Selected</th>
+                  <th>Results</th>
+                  <th>Delete All</th>
+                  <th>Export All</th>
+                </tr>
+              </thead>
+              <tbody>
+                <template v-for="camera in camerasWithRecordings" :key="camera.uniqueName">
+                  <tr>
+                    <td>{{ camera.nickname }}</td>
+                    <td>
+                      <pv-select v-model="selectedRecordings[camera.uniqueName]" :items="camera.recordings" />
+                    </td>
+                    <td class="text-right">
+                      <v-btn
+                        icon
+                        small
+                        color="buttonPassive"
+                        title="Replay selected recording through this camera's pipeline"
+                        :variant="theme.global.name.value === 'LightTheme' ? 'elevated' : 'outlined'"
+                        @click="replayRecording(camera)"
+                      >
+                        <v-icon size="large">mdi-play</v-icon>
+                      </v-btn>
+                    </td>
+                    <td class="text-right">
+                      <v-btn
+                        icon
+                        small
+                        color="error"
+                        title="Delete Selected Recording"
+                        :variant="theme.global.name.value === 'LightTheme' ? 'elevated' : 'outlined'"
+                        @click="
+                          () =>
+                            (confirmDeleteDialog = {
+                              show: true,
+                              recordings: [selectedRecordings[camera.uniqueName] || ''],
+                              cameraUniqueName: camera.uniqueName
+                            })
+                        "
+                      >
+                        <v-icon size="large">mdi-trash-can-outline</v-icon>
+                      </v-btn>
+                    </td>
+                    <td class="text-right">
+                      <v-btn
+                        icon
+                        small
+                        color="buttonPassive"
+                        title="Export Selected Recording"
+                        :variant="theme.global.name.value === 'LightTheme' ? 'elevated' : 'outlined'"
+                        @click="downloadIndividualRecording(camera)"
+                      >
+                        <v-icon size="large">mdi-export</v-icon>
+                      </v-btn>
+                    </td>
+                    <td class="text-right">
+                      <v-btn
+                        icon
+                        small
+                        color="buttonPassive"
+                        title="Show per-tuning results for the selected recording"
+                        :variant="theme.global.name.value === 'LightTheme' ? 'elevated' : 'outlined'"
+                        @click="toggleResults(camera)"
+                      >
+                        <v-icon size="large">
+                          {{
+                            expandedResults[resultsKey(camera.uniqueName, selectedRecordings[camera.uniqueName] || "")]
+                              ? "mdi-chevron-up"
+                              : "mdi-chevron-down"
+                          }}
+                        </v-icon>
+                      </v-btn>
+                    </td>
+                    <td class="text-right">
+                      <v-btn
+                        icon
+                        small
+                        color="error"
+                        title="Delete Recordings"
+                        :variant="theme.global.name.value === 'LightTheme' ? 'elevated' : 'outlined'"
+                        @click="
+                          () =>
+                            (confirmDeleteDialog = {
+                              show: true,
+                              recordings: camera.recordings,
+                              cameraUniqueName: camera.uniqueName
+                            })
+                        "
+                      >
+                        <v-icon size="large">mdi-trash-can-outline</v-icon>
+                      </v-btn>
+                    </td>
+                    <td class="text-right">
+                      <v-btn
+                        icon
+                        small
+                        color="buttonPassive"
+                        title="Export Recordings"
+                        :variant="theme.global.name.value === 'LightTheme' ? 'elevated' : 'outlined'"
+                        @click="downloadCameraRecordings(camera)"
+                      >
+                        <v-icon size="large">mdi-export</v-icon>
+                      </v-btn>
+                    </td>
+                  </tr>
+                  <tr v-if="isReplayingHere(camera.uniqueName)" class="replay-preview-row">
+                    <td colspan="8">
+                      <div class="replay-preview-container">
+                        <photon-camera-stream
+                          :id="`replay-preview-${camera.uniqueName}`"
+                          stream-type="Processed"
+                          :camera-settings="camera"
+                        />
+                      </div>
+                    </td>
+                  </tr>
+                  <tr
+                    v-if="
+                      selectedRecordings[camera.uniqueName] &&
+                      expandedResults[resultsKey(camera.uniqueName, selectedRecordings[camera.uniqueName])]
+                    "
+                    class="results-detail-row"
+                  >
+                    <td colspan="8">
+                      <div class="results-detail">
+                        <div
+                          v-if="resultsLoading[resultsKey(camera.uniqueName, selectedRecordings[camera.uniqueName])]"
+                          class="results-empty"
+                        >
+                          Loading…
+                        </div>
+                        <div
+                          v-else-if="
+                            (resultsCache[resultsKey(camera.uniqueName, selectedRecordings[camera.uniqueName])] || [])
+                              .length === 0
+                          "
+                          class="results-empty"
+                        >
+                          No exported results yet for this recording.
+                        </div>
+                        <table v-else class="results-table">
+                          <thead>
+                            <tr>
+                              <th>Hash</th>
+                              <th>Pipeline</th>
+                              <th>Result Count</th>
+                              <th>TSS</th>
+                              <th>Download</th>
+                            </tr>
+                          </thead>
+                          <tbody>
+                            <tr
+                              v-for="info in resultsCache[
+                                resultsKey(camera.uniqueName, selectedRecordings[camera.uniqueName])
+                              ]"
+                              :key="info.hash"
+                            >
+                              <td>{{ info.hash.substring(0, 8) }}</td>
+                              <td>{{ info.pipelineType }}</td>
+                              <td>{{ info.resultCount }}</td>
+                              <td>
+                                <v-chip v-if="!info.tssActiveAtRecord" size="x-small" color="warning" variant="flat">
+                                  no TSS
+                                </v-chip>
+                                <v-chip v-else size="x-small" color="success" variant="flat">TSS</v-chip>
+                              </td>
+                              <td>
+                                <a
+                                  :href="
+                                    resultDownloadHref(
+                                      camera.uniqueName,
+                                      selectedRecordings[camera.uniqueName],
+                                      info.hash
+                                    )
+                                  "
+                                  download
+                                >
+                                  <v-icon color="primary">mdi-download</v-icon>
+                                </a>
+                              </td>
+                            </tr>
+                          </tbody>
+                        </table>
+                      </div>
+                    </td>
+                  </tr>
+                </template>
+              </tbody>
+            </v-table>
+          </v-col>
+        </v-row>
+      </div>
+    </div>
+  </v-card>
+
+  <pv-delete-modal
+    v-model="showNukeDialog"
+    title="Clear All Recordings"
+    description="This will permanently delete all recordings from all cameras. This action cannot be undone."
+    delete-text="Delete Recordings"
+    :backup="() => downloadAllRecordings()"
+    @confirm="nukeRecordings"
+  />
+
+  <pv-delete-modal
+    v-model="confirmDeleteDialog.show"
+    title="Confirm Delete Recordings"
+    :description="'Are you sure you want to delete the recording(s) ' + confirmDeleteDialog.recordings.join(', ') + '?'"
+    @confirm="() => deleteRecordings(confirmDeleteDialog.recordings, confirmDeleteDialog.cameraUniqueName)"
+  />
+</template>
+
+<style scoped lang="scss">
+.v-col-12 > .v-btn {
+  width: 100%;
+}
+
+.pt-10px {
+  padding-top: 10px !important;
+}
+
+@media only screen and (max-width: 351px) {
+  .open-icon {
+    margin: 0 !important;
+  }
+  .open-label {
+    display: none;
+  }
+}
+.replay-preview-row td {
+  padding: 0.5rem !important;
+  background-color: rgba(0, 0, 0, 0.2);
+}
+.replay-preview-container {
+  width: 100%;
+  max-width: 640px;
+  margin: 0 auto;
+  aspect-ratio: 16 / 9;
+}
+
+.results-detail-row td {
+  padding: 0.5rem !important;
+  background-color: rgba(0, 0, 0, 0.15);
+}
+.results-detail {
+  padding: 0.25rem 0.75rem;
+}
+.results-empty {
+  font-style: italic;
+  opacity: 0.7;
+  padding: 0.5rem 0;
+}
+.results-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-family: monospace !important;
+}
+.results-table th,
+.results-table td {
+  padding: 0.25rem 0.5rem;
+  text-align: center;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.08);
+}
+.results-table th {
+  font-weight: 600;
+  opacity: 0.8;
+}
+.results-table tr:last-child td {
+  border-bottom: none;
+}
+
+.v-table {
+  width: 100%;
+  height: 100%;
+  text-align: center;
+
+  th,
+  td {
+    font-size: 1rem !important;
+    color: white !important;
+    text-align: center !important;
+  }
+
+  td {
+    font-family: monospace !important;
+  }
+
+  ::-webkit-scrollbar {
+    width: 0;
+    height: 0.55em;
+    border-radius: 5px;
+  }
+
+  ::-webkit-scrollbar-track {
+    -webkit-box-shadow: inset 0 0 6px rgba(0, 0, 0, 0.3);
+    border-radius: 10px;
+  }
+
+  ::-webkit-scrollbar-thumb {
+    background-color: rgb(var(--v-theme-accent));
+    border-radius: 10px;
+  }
+}
+</style>
diff --git a/photon-client/src/composables/useReplayStatus.ts b/photon-client/src/composables/useReplayStatus.ts
new file mode 100644
index 0000000000..44ccb17422
--- /dev/null
+++ b/photon-client/src/composables/useReplayStatus.ts
@@ -0,0 +1,40 @@
+import { inject, onUnmounted, ref } from "vue";
+
+// Mirrors VisionModule.ReplayStatus on the server. currentFrame / totalFrames
+// are Java `long`s on the wire; safe to treat as `number` here — a recording
+// would need >2^53 frames (~285 million years at 1000 fps) to overflow.
+export interface ActiveReplay {
+  cameraUniqueName: string;
+  recordingName: string;
+  currentFrame: number;
+  totalFrames: number;
+}
+
+// Must be called from a component setup() — uses inject() and onUnmounted().
+export function useReplayStatus(pollIntervalMs = 250) {
+  const address = inject<string>("backendHost");
+  const active = ref<ActiveReplay[]>([]);
+
+  if (!address) {
+    return { active };
+  }
+
+  const poll = async () => {
+    try {
+      const res = await fetch(`http://${address}/api/recordings/replay/status`, { cache: "no-store" });
+      if (res.ok) {
+        active.value = (await res.json()) as ActiveReplay[];
+      }
+    } catch {
+      // Network blip; keep the last value rather than flapping the banner.
+    }
+  };
+
+  const timer = window.setInterval(() => {
+    void poll();
+  }, pollIntervalMs);
+  void poll();
+  onUnmounted(() => window.clearInterval(timer));
+
+  return { active };
+}
diff --git a/photon-client/src/stores/settings/CameraSettingsStore.ts b/photon-client/src/stores/settings/CameraSettingsStore.ts
index a9ce460354..b0461e23b6 100644
--- a/photon-client/src/stores/settings/CameraSettingsStore.ts
+++ b/photon-client/src/stores/settings/CameraSettingsStore.ts
@@ -96,6 +96,9 @@ export const useCameraSettingsStore = defineStore("cameraSettings", {
     },
     hasConnected(): boolean {
       return this.currentCameraSettings.hasConnected;
+    },
+    camerasWithRecordings(): UiCameraConfiguration[] {
+      return Object.values(this.cameras).filter((camera) => camera.recordings.length > 0);
     }
   },
   actions: {
@@ -144,7 +147,8 @@ export const useCameraSettingsStore = defineStore("cameraSettings", {
           fpsLimit: d.fpsLimit,
           isConnected: d.isConnected,
           hasConnected: d.hasConnected,
-          mismatch: d.mismatch
+          mismatch: d.mismatch,
+          recordings: d.recordings
         };
         return acc;
       }, {});
diff --git a/photon-client/src/stores/settings/GeneralSettingsStore.ts b/photon-client/src/stores/settings/GeneralSettingsStore.ts
index c7ddcd4e74..fe7651c43b 100644
--- a/photon-client/src/stores/settings/GeneralSettingsStore.ts
+++ b/photon-client/src/stores/settings/GeneralSettingsStore.ts
@@ -78,7 +78,9 @@ export const useSettingsStore = defineStore("settings", {
       availableModels: [],
       supportedBackends: [],
       conflictingHostname: false,
-      conflictingCameras: ""
+      conflictingCameras: "",
+      recordingStrategy: "SNAPSHOTS",
+      supportedRecordingStrategies: ["SNAPSHOTS"]
     },
     network: {
       ntServerAddress: "",
@@ -167,7 +169,9 @@ export const useSettingsStore = defineStore("settings", {
         availableModels: data.general.availableModels || undefined,
         supportedBackends: data.general.supportedBackends || [],
         conflictingHostname: data.general.conflictingHostname || false,
-        conflictingCameras: data.general.conflictingCameras || ""
+        conflictingCameras: data.general.conflictingCameras || "",
+        recordingStrategy: data.general.recordingStrategy,
+        supportedRecordingStrategies: data.general.supportedRecordingStrategies
       };
       this.lighting = data.lighting;
       this.network = data.networkSettings;
@@ -186,6 +190,12 @@ export const useSettingsStore = defineStore("settings", {
         enabledLEDPercentage: brightness
       };
       useStateStore().websocket?.send(payload);
+    },
+    setRecordingStrategy(strategy: string) {
+      const payload = {
+        recordingStrategy: strategy
+      };
+      useStateStore().websocket?.send(payload);
     }
   }
 });
diff --git a/photon-client/src/types/SettingTypes.ts b/photon-client/src/types/SettingTypes.ts
index 291f812abb..490a720316 100644
--- a/photon-client/src/types/SettingTypes.ts
+++ b/photon-client/src/types/SettingTypes.ts
@@ -15,6 +15,8 @@ export interface GeneralSettings {
   supportedBackends: string[];
   conflictingHostname: boolean;
   conflictingCameras: string;
+  recordingStrategy: string;
+  supportedRecordingStrategies: string[];
 }
 
 export interface ObjectDetectionModelProperties {
@@ -281,6 +283,8 @@ export interface UiCameraConfiguration {
   isConnected: boolean;
   hasConnected: boolean;
   mismatch: boolean;
+
+  recordings: string[];
 }
 
 export interface CameraSettingsChangeRequest {
@@ -449,7 +453,8 @@ export const PlaceholderCameraSettings: UiCameraConfiguration = reactive({
   fpsLimit: -1,
   isConnected: true,
   hasConnected: true,
-  mismatch: false
+  mismatch: false,
+  recordings: []
 });
 
 export enum CalibrationBoardTypes {
diff --git a/photon-client/src/types/WebsocketDataTypes.ts b/photon-client/src/types/WebsocketDataTypes.ts
index d1f18bc29d..ea7ec74f85 100644
--- a/photon-client/src/types/WebsocketDataTypes.ts
+++ b/photon-client/src/types/WebsocketDataTypes.ts
@@ -71,6 +71,7 @@ export interface WebsocketCameraSettingsUpdate {
   isConnected: boolean;
   hasConnected: boolean;
   mismatch: boolean;
+  recordings: string[];
 }
 export interface WebsocketNTUpdate {
   connected: boolean;
diff --git a/photon-client/src/views/GeneralSettingsView.vue b/photon-client/src/views/GeneralSettingsView.vue
index 24d6403506..8aec521b2e 100644
--- a/photon-client/src/views/GeneralSettingsView.vue
+++ b/photon-client/src/views/GeneralSettingsView.vue
@@ -4,6 +4,7 @@ import GlobalSettingsCard from "@/components/settings/GlobalSettingsCard.vue";
 import LightingControlCard from "@/components/settings/LEDControlCard.vue";
 import { useSettingsStore } from "@/stores/settings/GeneralSettingsStore";
 import ApriltagControlCard from "@/components/settings/ApriltagControlCard.vue";
+import RecordingsCard from "@/components/settings/RecordingsCard.vue";
 import DeviceCard from "@/components/settings/DeviceCard.vue";
 </script>
 
@@ -13,6 +14,7 @@ import DeviceCard from "@/components/settings/DeviceCard.vue";
     <GlobalSettingsCard />
     <ObjectDetectionCard v-if="useSettingsStore().general.supportedBackends.length > 0" />
     <LightingControlCard v-if="useSettingsStore().lighting.supported" />
+    <RecordingsCard />
     <Suspense>
       <!-- Allows us to import three js when it's actually needed  -->
       <ApriltagControlCard />
diff --git a/photon-core/src/main/java/org/photonvision/common/configuration/ConfigManager.java b/photon-core/src/main/java/org/photonvision/common/configuration/ConfigManager.java
index d8fe576228..9148f206bb 100644
--- a/photon-core/src/main/java/org/photonvision/common/configuration/ConfigManager.java
+++ b/photon-core/src/main/java/org/photonvision/common/configuration/ConfigManager.java
@@ -372,6 +372,13 @@ public File getModelsDirectory() {
         return ret;
     }
 
+    /** Get (and create if not present) the subfolder where recordings are stored */
+    public File getRecordingsDirectory() {
+        var ret = new File(configDirectoryFile, "recordings");
+        if (!ret.exists()) ret.mkdirs();
+        return ret;
+    }
+
     /**
      * Disable flushing settings to disk as part of our JVM exit hook. Used to prevent uploading all
      * settings from getting its new configs overwritten at program exit and before they're all
diff --git a/photon-core/src/main/java/org/photonvision/common/configuration/HardwareConfig.java b/photon-core/src/main/java/org/photonvision/common/configuration/HardwareConfig.java
index 387ba6bf3a..6455c68699 100644
--- a/photon-core/src/main/java/org/photonvision/common/configuration/HardwareConfig.java
+++ b/photon-core/src/main/java/org/photonvision/common/configuration/HardwareConfig.java
@@ -19,6 +19,7 @@
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import java.util.ArrayList;
+import org.photonvision.vision.pipeline.FrameRecorder.RecordingStrategy;
 
 @JsonIgnoreProperties(ignoreUnknown = true)
 public class HardwareConfig {
@@ -43,6 +44,8 @@ public class HardwareConfig {
     public final String restartHardwareCommand;
     public final double vendorFOV; // -1 for unmanaged
 
+    public final RecordingStrategy recordingStrategy;
+
     public HardwareConfig(
             String deviceName,
             ArrayList<Integer> ledPins,
@@ -57,7 +60,8 @@ public HardwareConfig(
             String setPWMFrequencyCommand,
             String releaseGPIOCommand,
             String restartHardwareCommand,
-            double vendorFOV) {
+            double vendorFOV,
+            RecordingStrategy recordingStrategy) {
         this.deviceName = deviceName;
         this.ledPins = ledPins;
         this.ledsCanDim = ledsCanDim;
@@ -72,6 +76,7 @@ public HardwareConfig(
         this.releaseGPIOCommand = releaseGPIOCommand;
         this.restartHardwareCommand = restartHardwareCommand;
         this.vendorFOV = vendorFOV;
+        this.recordingStrategy = recordingStrategy;
     }
 
     public HardwareConfig() {
@@ -89,6 +94,7 @@ public HardwareConfig() {
         releaseGPIOCommand = "";
         restartHardwareCommand = "";
         vendorFOV = -1;
+        recordingStrategy = RecordingStrategy.SNAPSHOTS;
     }
 
     /**
@@ -139,6 +145,8 @@ public String toString() {
                 + restartHardwareCommand
                 + ", vendorFOV="
                 + vendorFOV
+                + ", recordingStrategy="
+                + recordingStrategy
                 + "]";
     }
 }
diff --git a/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java b/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java
index 53e7cba3a4..9661636536 100644
--- a/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java
+++ b/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java
@@ -32,9 +32,12 @@
 import org.photonvision.vision.pipeline.result.CalibrationPipelineResult;
 import org.photonvision.vision.target.TrackedTarget;
 import org.wpilib.math.geometry.Transform3d;
+import org.wpilib.networktables.BooleanPublisher;
+import org.wpilib.networktables.IntegerPublisher;
 import org.wpilib.networktables.NetworkTable;
 import org.wpilib.networktables.NetworkTableEvent;
 import org.wpilib.networktables.NetworkTablesJNI;
+import org.wpilib.networktables.StringPublisher;
 
 public class NTDataPublisher implements CVPipelineResultConsumer {
     private final Logger logger = new Logger(NTDataPublisher.class, LogGroup.General);
@@ -51,22 +54,38 @@ public class NTDataPublisher implements CVPipelineResultConsumer {
     private final BooleanSupplier driverModeSupplier;
     private final Consumer<Boolean> driverModeConsumer;
 
+    NTDataChangeListener recordingListener;
+    private final BooleanSupplier recordingSupplier;
+    private final Consumer<Boolean> recordingConsumer;
     NTDataChangeListener fpsLimitListener;
     private final Consumer<Integer> fpsLimitConsumer;
     private final Supplier<Integer> fpsLimitSupplier;
 
+    // Replay-state publishers — created in updateEntries(), closed in removeEntries(). Driven by
+    // explicit publishReplayState / publishReplayProgress calls from VisionModule rather than
+    // re-published every frame like the rest of the per-result topics, because the values change
+    // only on replay start / progress tick / end.
+    private BooleanPublisher isReplayingPublisher;
+    private IntegerPublisher replayProgressCurrentFramePublisher;
+    private IntegerPublisher replayProgressTotalFramesPublisher;
+    private StringPublisher replayProgressRecordingNamePublisher;
+
     public NTDataPublisher(
             String cameraNickname,
             Supplier<Integer> pipelineIndexSupplier,
             Consumer<Integer> pipelineIndexConsumer,
             BooleanSupplier driverModeSupplier,
             Consumer<Boolean> driverModeConsumer,
+            BooleanSupplier recordingSupplier,
+            Consumer<Boolean> recordingConsumer,
             Supplier<Integer> fpsLimitSupplier,
             Consumer<Integer> fpsLimitConsumer) {
         this.pipelineIndexSupplier = pipelineIndexSupplier;
         this.pipelineIndexConsumer = pipelineIndexConsumer;
         this.driverModeSupplier = driverModeSupplier;
         this.driverModeConsumer = driverModeConsumer;
+        this.recordingSupplier = recordingSupplier;
+        this.recordingConsumer = recordingConsumer;
         this.fpsLimitSupplier = fpsLimitSupplier;
         this.fpsLimitConsumer = fpsLimitConsumer;
 
@@ -111,6 +130,19 @@ private void onDriverModeChange(NetworkTableEvent entryNotification) {
         logger.debug("Set driver mode to " + newDriverMode);
     }
 
+    private void onRecordingChange(NetworkTableEvent entryNotification) {
+        var newRecording = entryNotification.valueData.value.getBoolean();
+        var originalRecording = recordingSupplier.getAsBoolean();
+
+        if (newRecording == originalRecording) {
+            logger.debug("Recording state is already " + newRecording);
+            return;
+        }
+
+        recordingConsumer.accept(newRecording);
+        logger.debug("Set recording state to " + newRecording);
+    }
+
     private void onFPSLimitChange(NetworkTableEvent entryNotification) {
         var newFPSLimit = (int) entryNotification.valueData.value.getInteger();
         var originalFPSLimit = fpsLimitSupplier.get();
@@ -127,12 +159,18 @@ private void onFPSLimitChange(NetworkTableEvent entryNotification) {
     private void removeEntries() {
         if (pipelineIndexListener != null) pipelineIndexListener.remove();
         if (driverModeListener != null) driverModeListener.remove();
+        if (recordingListener != null) recordingListener.remove();
+        if (isReplayingPublisher != null) isReplayingPublisher.close();
+        if (replayProgressCurrentFramePublisher != null) replayProgressCurrentFramePublisher.close();
+        if (replayProgressTotalFramesPublisher != null) replayProgressTotalFramesPublisher.close();
+        if (replayProgressRecordingNamePublisher != null) replayProgressRecordingNamePublisher.close();
         ts.removeEntries();
     }
 
     private void updateEntries() {
         if (pipelineIndexListener != null) pipelineIndexListener.remove();
         if (driverModeListener != null) driverModeListener.remove();
+        if (recordingListener != null) recordingListener.remove();
         if (fpsLimitListener != null) fpsLimitListener.remove();
 
         ts.updateEntries();
@@ -145,9 +183,47 @@ private void updateEntries() {
                 new NTDataChangeListener(
                         ts.subTable.getInstance(), ts.driverModeSubscriber, this::onDriverModeChange);
 
+        recordingListener =
+                new NTDataChangeListener(
+                        ts.subTable.getInstance(), ts.recordingSubscriber, this::onRecordingChange);
         fpsLimitListener =
                 new NTDataChangeListener(
                         ts.subTable.getInstance(), ts.fpsLimitSubscriber, this::onFPSLimitChange);
+
+        // Replay-state topics live in the same per-camera subtable as the existing recording /
+        // driverMode topics. updateCameraNickname() calls remove + update so these migrate when
+        // the camera is renamed.
+        isReplayingPublisher = ts.subTable.getBooleanTopic("isReplaying").publish();
+        isReplayingPublisher.setDefault(false);
+        replayProgressCurrentFramePublisher =
+                ts.subTable.getIntegerTopic("replayProgressCurrentFrame").publish();
+        replayProgressTotalFramesPublisher =
+                ts.subTable.getIntegerTopic("replayProgressTotalFrames").publish();
+        replayProgressRecordingNamePublisher =
+                ts.subTable.getStringTopic("replayProgressRecordingName").publish();
+    }
+
+    /** Set the {@code isReplaying} topic. Called from {@code VisionModule.startReplay/cancel}. */
+    public void publishReplayState(boolean isReplaying) {
+        if (isReplayingPublisher != null) isReplayingPublisher.set(isReplaying);
+    }
+
+    /**
+     * Set the three {@code replayProgress*} topics. Called from the {@link
+     * org.photonvision.vision.frame.provider.FileLogFrameProvider} progress callback on the vision
+     * thread (once per emitted frame) and from {@code startReplay} to zero things out at the start of
+     * a replay.
+     */
+    public void publishReplayProgress(long currentFrame, long totalFrames, String recordingName) {
+        if (replayProgressCurrentFramePublisher != null) {
+            replayProgressCurrentFramePublisher.set(currentFrame);
+        }
+        if (replayProgressTotalFramesPublisher != null) {
+            replayProgressTotalFramesPublisher.set(totalFrames);
+        }
+        if (replayProgressRecordingNamePublisher != null) {
+            replayProgressRecordingNamePublisher.set(recordingName == null ? "" : recordingName);
+        }
     }
 
     public void updateCameraNickname(String newCameraNickname) {
@@ -197,6 +273,7 @@ public void accept(CVPipelineResult result) {
 
         ts.pipelineIndexPublisher.set(pipelineIndexSupplier.get());
         ts.driverModePublisher.set(driverModeSupplier.getAsBoolean());
+        ts.recordingPublisher.set(recordingSupplier.getAsBoolean());
         ts.fpsLimitPublisher.set(fpsLimitSupplier.get());
         ts.latencyMillisEntry.set(acceptedResult.getLatencyMillis());
         ts.fpsEntry.set(acceptedResult.fps);
diff --git a/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDriverStation.java b/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDriverStation.java
index 5001972395..bcdeb663a8 100644
--- a/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDriverStation.java
+++ b/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDriverStation.java
@@ -75,7 +75,12 @@ public NTDriverStation(NetworkTableInstance inst) {
                         var word = NTDriverStation.getControlWord(event.valueData.value.getInteger());
 
                         printTransition(this.lastControlWord, word);
-                        printMatchData();
+
+                        String matchData = printMatchData();
+                        if (!matchData.isBlank()) {
+                            logger.info(matchData);
+                        }
+
                         this.lastControlWord = word;
                     }
                 });
@@ -84,7 +89,12 @@ public NTDriverStation(NetworkTableInstance inst) {
         NtControlWord word = NTDriverStation.getControlWord(this.ntControlWord.get());
 
         printTransition(this.lastControlWord, word);
-        printMatchData();
+
+        String matchData = printMatchData();
+        if (!matchData.isBlank()) {
+            logger.info(matchData);
+        }
+
         this.lastControlWord = word;
     }
 
@@ -92,12 +102,12 @@ private void printTransition(NtControlWord old, NtControlWord newWord) {
         logger.info("ROBOT TRANSITIONED MODES! From " + old.toString() + " to " + newWord.toString());
     }
 
-    private void printMatchData() {
+    public String printMatchData() {
         // this information seems to be published at the same time
         String event = eventName.get();
         if (event.isBlank()) {
             // nothing to log
-            return;
+            return "";
         }
         String type =
                 switch ((int) matchType.get()) {
@@ -121,7 +131,66 @@ private void printMatchData() {
                         + replay
                         + ", Station: "
                         + station;
-        logger.info(message);
+        return message;
+    }
+
+    /**
+     * Compares two match data strings and returns a negative, 0, or a postive if the first is less
+     * than, equal to, or greater than the second.
+     *
+     * @param first
+     * @param second
+     * @return a negative, 0, or a positive if the first is less than, equal to, or greater than the
+     *     second
+     */
+    public static int compareMatchData(String first, String second) {
+        String[] firstParts = first.split(", ");
+        String[] secondParts = second.split(", ");
+
+        String firstMatchInfo = firstParts[1].split(" ")[1];
+        String secondMatchInfo = secondParts[1].split(" ")[1];
+
+        String firstType = firstMatchInfo.substring(0, 1);
+        String secondType = secondMatchInfo.substring(0, 1);
+
+        int firstCmp;
+        int secondCmp;
+        switch (firstType) {
+            case "P" -> firstCmp = 1;
+            case "Q" -> firstCmp = 2;
+            case "E" -> firstCmp = 3;
+            default -> firstCmp = 0;
+        }
+        switch (secondType) {
+            case "P" -> secondCmp = 1;
+            case "Q" -> secondCmp = 2;
+            case "E" -> secondCmp = 3;
+            default -> secondCmp = 0;
+        }
+
+        if (Integer.compare(firstCmp, secondCmp) != 0) {
+            return Integer.compare(firstCmp, secondCmp);
+        }
+
+        int comp;
+
+        try {
+            // same type, compare match numbers
+            int firstMatchNumber = Integer.parseInt(firstMatchInfo.substring(1));
+            int secondMatchNumber = Integer.parseInt(secondMatchInfo.substring(1));
+            if (Integer.compare(firstMatchNumber, secondMatchNumber) != 0) {
+                return Integer.compare(firstMatchNumber, secondMatchNumber);
+            }
+            // same match number, compare replay numbers
+            int firstReplay = Integer.parseInt(firstParts[2].split(" ")[1]);
+            int secondReplay = Integer.parseInt(secondParts[2].split(" ")[1]);
+            comp = Integer.compare(firstReplay, secondReplay);
+        } catch (NumberFormatException e) {
+            // if we can't parse numbers, just say they're equal
+            return 0;
+        }
+
+        return comp;
     }
 
     // Copied from
diff --git a/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NetworkTablesManager.java b/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NetworkTablesManager.java
index 5f0e37ba73..247beb3a5f 100644
--- a/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NetworkTablesManager.java
+++ b/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NetworkTablesManager.java
@@ -21,6 +21,7 @@
 import java.util.Arrays;
 import java.util.EnumSet;
 import java.util.HashMap;
+import java.util.List;
 import org.photonvision.PhotonVersion;
 import org.photonvision.common.configuration.CameraConfiguration;
 import org.photonvision.common.configuration.ConfigManager;
@@ -35,14 +36,18 @@
 import org.photonvision.common.networking.NetworkUtils;
 import org.photonvision.common.util.TimedTaskManager;
 import org.photonvision.common.util.file.JacksonUtils;
+import org.photonvision.vision.processes.VisionModule;
+import org.photonvision.vision.processes.VisionSourceManager;
 import org.wpilib.driverstation.Alert;
 import org.wpilib.driverstation.Alert.Level;
+import org.wpilib.networktables.IntegerSubscriber;
 import org.wpilib.networktables.LogMessage;
 import org.wpilib.networktables.MultiSubscriber;
 import org.wpilib.networktables.NetworkTable;
 import org.wpilib.networktables.NetworkTableEvent;
 import org.wpilib.networktables.NetworkTableEvent.Kind;
 import org.wpilib.networktables.NetworkTableInstance;
+import org.wpilib.networktables.StringArraySubscriber;
 import org.wpilib.networktables.StringSubscriber;
 import org.wpilib.smartdashboard.SmartDashboard;
 import org.wpilib.vision.apriltag.AprilTagFieldLayout;
@@ -79,6 +84,12 @@ public class NetworkTablesManager {
     private StringSubscriber m_fieldLayoutSubscriber =
             kRootTable.getStringTopic(kFieldLayoutName).subscribe("");
 
+    private StringArraySubscriber m_recordingCamerasSubscriber =
+            kRootTable.getStringArrayTopic("reserveRecordingSpace").subscribe(new String[0]);
+
+    private IntegerSubscriber m_reserveSubscriber =
+            kRootTable.getIntegerTopic("reserveRecordingSpace").subscribe(0);
+
     private final TimeSyncManager m_timeSync = new TimeSyncManager(kRootTable);
 
     NTDriverStation ntDriverStation;
@@ -91,6 +102,9 @@ private NetworkTablesManager() {
         ntInstance.addListener(
                 m_fieldLayoutSubscriber, EnumSet.of(Kind.kValueAll), this::onFieldLayoutChanged);
 
+        ntInstance.addListener(
+                m_reserveSubscriber, EnumSet.of(Kind.kValueAll), this::onReserveRecordingSpaceChanged);
+
         ntDriverStation = new NTDriverStation(this.getNTInst());
 
         // This should start as false, since we don't know if there's a conflict yet
@@ -155,6 +169,16 @@ private void logNtMessage(NetworkTableEvent event) {
                 pvlevel);
     }
 
+    /**
+     * Get a string describing the current match data from NT
+     *
+     * @return A string describing the current match data from NT, or an empty string if no match data
+     *     is available
+     */
+    public String getMatchData() {
+        return ntDriverStation.printMatchData();
+    }
+
     public void checkNtConnectState(NetworkTableEvent event) {
         var isConnEvent = event.is(Kind.kConnected);
         var isDisconnEvent = event.is(Kind.kDisconnected);
@@ -213,6 +237,22 @@ private void onFieldLayoutChanged(NetworkTableEvent event) {
         }
     }
 
+    private void onReserveRecordingSpaceChanged(NetworkTableEvent event) {
+        List<String> cameraNames = List.of(m_recordingCamerasSubscriber.get());
+
+        if (HardwareManager.getInstance()
+                .reserveRecordingSpace(
+                        VisionSourceManager.getInstance().getVisionModules().stream()
+                                .filter(v -> cameraNames.contains(v.getCameraConfiguration().nickname))
+                                .toList()
+                                .toArray(new VisionModule[0]))) {
+            m_reserveSubscriber.getTopic().publish().set(0);
+        } else {
+            logger.warn("Failed to reserve recording space for cameras: " + cameraNames);
+            m_reserveSubscriber.getTopic().publish().set(1);
+        }
+    }
+
     public void broadcastConnectedStatus() {
         TimedTaskManager.getInstance().addOneShotTask(this::broadcastConnectedStatusImpl, 1000L);
     }
diff --git a/photon-core/src/main/java/org/photonvision/common/dataflow/websocket/UICameraConfiguration.java b/photon-core/src/main/java/org/photonvision/common/dataflow/websocket/UICameraConfiguration.java
index 617822c85d..3d69fdc4b6 100644
--- a/photon-core/src/main/java/org/photonvision/common/dataflow/websocket/UICameraConfiguration.java
+++ b/photon-core/src/main/java/org/photonvision/common/dataflow/websocket/UICameraConfiguration.java
@@ -59,4 +59,7 @@ public class UICameraConfiguration {
     // Status for if the underlying device is present and such
     public boolean isConnected;
     public boolean hasConnected;
+
+    // List of all the recordings for this camera
+    public List<String> recordings;
 }
diff --git a/photon-core/src/main/java/org/photonvision/common/dataflow/websocket/UIGeneralSettings.java b/photon-core/src/main/java/org/photonvision/common/dataflow/websocket/UIGeneralSettings.java
index 087ec2f749..408d1edb1d 100644
--- a/photon-core/src/main/java/org/photonvision/common/dataflow/websocket/UIGeneralSettings.java
+++ b/photon-core/src/main/java/org/photonvision/common/dataflow/websocket/UIGeneralSettings.java
@@ -32,7 +32,9 @@ public UIGeneralSettings(
             String hardwarePlatform,
             String wpilibArch,
             boolean conflictingHostname,
-            String conflictingCameras) {
+            String conflictingCameras,
+            String recordingStrategy,
+            List<String> supportedRecordingStrategies) {
         this.version = version;
         this.imageVersion = imageVersion;
         this.gpuAcceleration = gpuAcceleration;
@@ -44,6 +46,8 @@ public UIGeneralSettings(
         this.wpilibArch = wpilibArch;
         this.conflictingHostname = conflictingHostname;
         this.conflictingCameras = conflictingCameras;
+        this.recordingStrategy = recordingStrategy;
+        this.supportedRecordingStrategies = supportedRecordingStrategies;
     }
 
     public String version;
@@ -57,4 +61,6 @@ public UIGeneralSettings(
     public String wpilibArch;
     public boolean conflictingHostname;
     public String conflictingCameras;
+    public String recordingStrategy;
+    public List<String> supportedRecordingStrategies;
 }
diff --git a/photon-core/src/main/java/org/photonvision/common/dataflow/websocket/UIPhotonConfiguration.java b/photon-core/src/main/java/org/photonvision/common/dataflow/websocket/UIPhotonConfiguration.java
index 6e5a14eb09..94eb137c6e 100644
--- a/photon-core/src/main/java/org/photonvision/common/dataflow/websocket/UIPhotonConfiguration.java
+++ b/photon-core/src/main/java/org/photonvision/common/dataflow/websocket/UIPhotonConfiguration.java
@@ -28,6 +28,7 @@
 import org.photonvision.common.hardware.Platform;
 import org.photonvision.common.networking.NetworkManager;
 import org.photonvision.common.networking.NetworkUtils;
+import org.photonvision.vision.pipeline.FrameRecorder;
 import org.photonvision.vision.processes.VisionModule;
 import org.photonvision.vision.processes.VisionSourceManager;
 
@@ -67,7 +68,9 @@ public static UIPhotonConfiguration programStateToUi(PhotonConfiguration c) {
                                 Platform.getPlatformName(),
                                 Platform.getNativePlatform(),
                                 NetworkTablesManager.getInstance().conflictingHostname,
-                                NetworkTablesManager.getInstance().conflictingCameras),
+                                NetworkTablesManager.getInstance().conflictingCameras,
+                                c.getHardwareConfig().recordingStrategy.name(),
+                                FrameRecorder.getSupportedStrategies().stream().map(Enum::name).toList()),
                         c.getApriltagFieldLayout()),
                 VisionSourceManager.getInstance().getVisionModules().stream()
                         .map(VisionModule::toUICameraConfig)
diff --git a/photon-core/src/main/java/org/photonvision/common/hardware/HardwareManager.java b/photon-core/src/main/java/org/photonvision/common/hardware/HardwareManager.java
index 98e223c124..e1d936df96 100644
--- a/photon-core/src/main/java/org/photonvision/common/hardware/HardwareManager.java
+++ b/photon-core/src/main/java/org/photonvision/common/hardware/HardwareManager.java
@@ -22,20 +22,27 @@
 import com.diozero.sbc.BoardPinInfo;
 import com.diozero.sbc.DeviceFactoryHelper;
 import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.function.Supplier;
+import org.apache.commons.io.FileUtils;
 import org.photonvision.common.configuration.ConfigManager;
 import org.photonvision.common.configuration.HardwareConfig;
 import org.photonvision.common.configuration.HardwareSettings;
 import org.photonvision.common.dataflow.networktables.NTDataChangeListener;
+import org.photonvision.common.dataflow.networktables.NTDriverStation;
 import org.photonvision.common.dataflow.networktables.NetworkTablesManager;
 import org.photonvision.common.hardware.gpio.CustomAdapter;
 import org.photonvision.common.hardware.gpio.CustomDeviceFactory;
+import org.photonvision.common.hardware.metrics.SystemMonitor;
 import org.photonvision.common.logging.LogGroup;
 import org.photonvision.common.logging.Logger;
 import org.photonvision.common.util.ShellExec;
+import org.photonvision.vision.pipeline.FrameRecorder.RecordingStrategy;
+import org.photonvision.vision.processes.VisionModule;
 import org.wpilib.networktables.IntegerPublisher;
 import org.wpilib.networktables.IntegerSubscriber;
 
@@ -249,4 +256,112 @@ private void updateStatus() {
         }
         statusLED.setStatus(status);
     }
+
+    /**
+     * Ensures there is enough space for new recordings by clearing stored recordings to free up disk
+     * space. This method should delete the oldest recordings, prioritizing recordings from matches
+     * over practice sessions regardless of age. We leave a default buffer of 5 GB, plus the space
+     * each module will need for a 5-minute recording.
+     *
+     * @param modules The vision modules that will be recording
+     * @return true if enough space was cleared, false otherwise
+     */
+    public boolean reserveRecordingSpace(VisionModule[] modules) {
+        double totalRequestedSpace = 5 * 1024; // Start with 5 GB buffer
+
+        for (VisionModule module : modules) {
+            totalRequestedSpace += module.recordingSpaceNeeded();
+        }
+
+        return reserveRecordingSpace(totalRequestedSpace);
+    }
+
+    /**
+     * Ensures there is enough space for new recordings by clearing stored recordings to free up disk
+     * space. This method should delete the oldest recordings, prioritizing recordings from matches
+     * over practice sessions regardless of age.
+     *
+     * @param requestedSpace The amount of space to free in MB
+     * @return true if enough space was cleared, false otherwise
+     */
+    public boolean reserveRecordingSpace(double requestedSpace) {
+        if (SystemMonitor.getInstance().getUsableDiskSpace() > requestedSpace * 1024 * 1024) {
+            return true; // Enough space already available
+        }
+
+        Path recordingsDir = ConfigManager.getInstance().getRecordingsDirectory().toPath();
+
+        // Create a list of all the recordings
+        ArrayList<Path> recordings = new ArrayList<>();
+        try {
+            if (!java.nio.file.Files.exists(recordingsDir)
+                    || !java.nio.file.Files.isDirectory(recordingsDir)) {
+                logger.error("Recordings directory does not exist");
+                return false; // No recordings directory
+            }
+
+            try (var cameraStream = java.nio.file.Files.list(recordingsDir)) {
+                cameraStream
+                        .filter(java.nio.file.Files::isDirectory)
+                        .forEach(
+                                cameraDir -> {
+                                    try (var recStream = java.nio.file.Files.list(cameraDir)) {
+                                        recStream.filter(java.nio.file.Files::isDirectory).forEach(recordings::add);
+                                    } catch (Exception e) {
+                                        // skip unreadable camera folder
+                                    }
+                                });
+            }
+        } catch (Exception e) {
+            return false; // Unable to list recordings
+        }
+
+        if (recordings.isEmpty()) {
+            return false; // No recordings to delete
+        }
+
+        // Create practice list and match list
+        ArrayList<Path> matchRecordings = new ArrayList<>();
+        ArrayList<Path> practiceRecordings = new ArrayList<>();
+
+        for (Path rec : recordings) {
+            String dirName = rec.getFileName().toString().toLowerCase();
+            if (dirName.startsWith("event")) {
+                matchRecordings.add(rec);
+            } else {
+                practiceRecordings.add(rec);
+            }
+        }
+
+        // Sort both lists based on solely the filename
+        matchRecordings.sort(
+                (a, b) ->
+                        NTDriverStation.compareMatchData(
+                                a.getFileName().toString(), b.getFileName().toString()));
+        practiceRecordings.sort(
+                (a, b) -> a.getFileName().toString().compareTo(b.getFileName().toString()));
+
+        while (requestedSpace * 1024 * 1024 > SystemMonitor.getInstance().getUsableDiskSpace()) {
+            Path toDelete = null;
+            if (!practiceRecordings.isEmpty()) {
+                toDelete = practiceRecordings.remove(0);
+            } else if (!matchRecordings.isEmpty()) {
+                toDelete = matchRecordings.remove(0);
+            } else {
+                return false; // No recordings left to delete
+            }
+            try {
+                FileUtils.deleteDirectory(toDelete.toFile());
+            } catch (Exception e) {
+                logger.error("Failed to delete recording: " + toDelete.toString(), e);
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public RecordingStrategy getRecordingStrategy() {
+        return hardwareConfig.recordingStrategy;
+    }
 }
diff --git a/photon-core/src/main/java/org/photonvision/common/util/PathSafety.java b/photon-core/src/main/java/org/photonvision/common/util/PathSafety.java
new file mode 100644
index 0000000000..e067df01af
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/common/util/PathSafety.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.common.util;
+
+import java.nio.file.InvalidPathException;
+import java.nio.file.Path;
+import java.util.Arrays;
+
+/** Helpers for resolving user-supplied path segments without allowing escape from a root. */
+public final class PathSafety {
+    private PathSafety() {}
+
+    /**
+     * Resolve user-supplied segments inside a trusted root, rejecting any input that would escape the
+     * root (e.g. {@code ".."}, absolute paths, embedded {@code "../"} sequences) or that the
+     * underlying filesystem refuses to parse.
+     *
+     * @param root the trusted root directory. The result is guaranteed to be inside this directory.
+     * @param segments user-supplied path segments, applied in order via {@link Path#resolve(String)}.
+     * @return the resolved, normalized, absolute path. Always inside {@code root}.
+     * @throws SecurityException if any segment is null/blank, contains characters the filesystem
+     *     can't parse, or if the resolved path is outside the root.
+     */
+    public static Path safeResolve(Path root, String... segments) {
+        Path rootAbs = root.toAbsolutePath().normalize();
+        Path resolved = rootAbs;
+        for (String segment : segments) {
+            if (segment == null || segment.isBlank()) {
+                throw new SecurityException("Empty path segment");
+            }
+            try {
+                resolved = resolved.resolve(segment);
+            } catch (InvalidPathException e) {
+                throw new SecurityException("Invalid path segment: " + segment, e);
+            }
+        }
+        resolved = resolved.normalize();
+        if (!resolved.startsWith(rootAbs)) {
+            throw new SecurityException("Path escapes root: " + Arrays.toString(segments));
+        }
+        return resolved;
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/FileVisionSource.java b/photon-core/src/main/java/org/photonvision/vision/camera/FileVisionSource.java
index 59e15ca59f..716e45b31a 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/FileVisionSource.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/FileVisionSource.java
@@ -20,7 +20,6 @@
 import java.nio.file.Path;
 import java.util.HashMap;
 import org.photonvision.common.configuration.CameraConfiguration;
-import org.photonvision.vision.frame.FrameProvider;
 import org.photonvision.vision.frame.FrameStaticProperties;
 import org.photonvision.vision.frame.provider.FileFrameProvider;
 import org.photonvision.vision.processes.VisionSource;
@@ -52,6 +51,7 @@ public FileVisionSource(CameraConfiguration cameraConfiguration) {
 
         settables =
                 new FileSourceSettables(cameraConfiguration, frameProvider.get().frameStaticProperties);
+        setFrameProvider(frameProvider);
     }
 
     public FileVisionSource(String name, String imagePath, double fov) {
@@ -64,11 +64,7 @@ public FileVisionSource(String name, String imagePath, double fov) {
         frameProvider = new FileFrameProvider(imagePath, fov);
         settables =
                 new FileSourceSettables(cameraConfiguration, frameProvider.get().frameStaticProperties);
-    }
-
-    @Override
-    public FrameProvider getFrameProvider() {
-        return frameProvider;
+        setFrameProvider(frameProvider);
     }
 
     @Override
diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/TestSource.java b/photon-core/src/main/java/org/photonvision/vision/camera/TestSource.java
index bbe62cd2cf..f722291152 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/TestSource.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/TestSource.java
@@ -17,7 +17,6 @@
 
 package org.photonvision.vision.camera;
 
-import java.util.*;
 import org.photonvision.common.configuration.CameraConfiguration;
 import org.photonvision.vision.frame.Frame;
 import org.photonvision.vision.frame.FrameProvider;
@@ -102,6 +101,16 @@ public boolean checkCameraConnected() {
             public boolean isConnected() {
                 return true;
             }
+
+            @Override
+            public void setRecording(boolean shouldRecord) {
+                throw new UnsupportedOperationException("Unimplemented method 'setRecording'");
+            }
+
+            @Override
+            public boolean getRecording() {
+                return false;
+            }
         };
     }
 
diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/USBCameraSource.java b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/USBCameraSource.java
index c25b8a3781..d2cdc93726 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/USBCameraSource.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/USBCameraSource.java
@@ -106,6 +106,7 @@ public USBCameraSource(CameraConfiguration config) {
 
             usbFrameProvider = new USBFrameProvider(camera, settables, this::onCameraConnected);
         }
+        setFrameProvider(usbFrameProvider);
     }
 
     /**
@@ -220,11 +221,6 @@ public QuirkyCamera getCameraQuirks() {
         return getCameraConfiguration().cameraQuirks;
     }
 
-    @Override
-    public FrameProvider getFrameProvider() {
-        return usbFrameProvider;
-    }
-
     @Override
     public VisionSourceSettables getSettables() {
         return this.settables;
@@ -246,6 +242,10 @@ public void release() {
         camera.close();
         usbFrameProvider.release();
         usbFrameProvider = null;
+        // Intentionally don't setFrameProvider(null): VisionRunner re-reads the provider
+        // every tick and would NPE if a release ran while the runner thread is still alive.
+        // VisionModule.stop() already joins the runner before release(), so the volatile
+        // can keep its stale reference; no live consumer remains.
     }
 
     @Override
diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/csi/LibcameraGpuSource.java b/photon-core/src/main/java/org/photonvision/vision/camera/csi/LibcameraGpuSource.java
index 62b1769773..97906306be 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/csi/LibcameraGpuSource.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/csi/LibcameraGpuSource.java
@@ -23,7 +23,6 @@
 import org.photonvision.common.logging.Logger;
 import org.photonvision.vision.camera.CameraType;
 import org.photonvision.vision.camera.QuirkyCamera;
-import org.photonvision.vision.frame.FrameProvider;
 import org.photonvision.vision.frame.provider.LibcameraGpuFrameProvider;
 import org.photonvision.vision.processes.VisionSource;
 import org.photonvision.vision.processes.VisionSourceSettables;
@@ -48,11 +47,7 @@ public LibcameraGpuSource(CameraConfiguration configuration) {
 
         settables = new LibcameraGpuSettables(configuration);
         frameProvider = new LibcameraGpuFrameProvider(settables);
-    }
-
-    @Override
-    public FrameProvider getFrameProvider() {
-        return frameProvider;
+        setFrameProvider(frameProvider);
     }
 
     @Override
@@ -107,5 +102,8 @@ public boolean hasLEDs() {
     public void release() {
         frameProvider.release();
         frameProvider = null;
+        // Intentionally don't setFrameProvider(null): see USBCameraSource.release() for the
+        // same reasoning — VisionRunner reads the provider every tick and joins on stop()
+        // before this runs, so the stale volatile reference has no live consumer.
     }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/frame/FrameProvider.java b/photon-core/src/main/java/org/photonvision/vision/frame/FrameProvider.java
index 7361a41a85..c9bdcf75b2 100644
--- a/photon-core/src/main/java/org/photonvision/vision/frame/FrameProvider.java
+++ b/photon-core/src/main/java/org/photonvision/vision/frame/FrameProvider.java
@@ -21,6 +21,7 @@
 import org.photonvision.vision.opencv.ImageRotationMode;
 import org.photonvision.vision.opencv.Releasable;
 import org.photonvision.vision.pipe.impl.HSVPipe;
+import org.photonvision.vision.pipeline.FrameRecorder;
 
 public abstract class FrameProvider implements Supplier<Frame>, Releasable {
     protected int sequenceID = 0;
@@ -31,6 +32,10 @@ public abstract class FrameProvider implements Supplier<Frame>, Releasable {
     // time
     public boolean cameraPropertiesCached = false;
 
+    // volatile so the vision thread's unsynchronised read in USBFrameProvider.getInputMat sees
+    // writes from the NT-listener-thread-driven setRecording / release without tearing.
+    public volatile FrameRecorder frameRecorder = null;
+
     protected void onCameraConnected() {
         cameraPropertiesCached = true;
     }
@@ -72,4 +77,8 @@ public boolean hasConnected() {
 
     /** Ask the camera to block for new frames (true) or use latest available (false) */
     public abstract void requestBlockForFrames(boolean blockForFrames);
+
+    public abstract void setRecording(boolean shouldRecord);
+
+    public abstract boolean getRecording();
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/frame/provider/FileFrameProvider.java b/photon-core/src/main/java/org/photonvision/vision/frame/provider/FileFrameProvider.java
index 2b281b517f..3ca1cc3d20 100644
--- a/photon-core/src/main/java/org/photonvision/vision/frame/provider/FileFrameProvider.java
+++ b/photon-core/src/main/java/org/photonvision/vision/frame/provider/FileFrameProvider.java
@@ -22,18 +22,21 @@
 import java.nio.file.Paths;
 import org.opencv.core.Mat;
 import org.opencv.imgcodecs.Imgcodecs;
+import org.photonvision.common.logging.LogGroup;
+import org.photonvision.common.logging.Logger;
 import org.photonvision.common.util.math.MathUtils;
 import org.photonvision.vision.calibration.CameraCalibrationCoefficients;
 import org.photonvision.vision.frame.FrameProvider;
 import org.photonvision.vision.frame.FrameStaticProperties;
 import org.photonvision.vision.opencv.CVMat;
-import org.photonvision.vision.opencv.Releasable;
 
 /**
  * A {@link FrameProvider} that will read and provide an image from a {@link java.nio.file.Path
  * path}.
  */
-public class FileFrameProvider extends CpuImageProcessor implements Releasable {
+public class FileFrameProvider extends CpuImageProcessor {
+    private static final Logger logger = new Logger(FileFrameProvider.class, LogGroup.Camera);
+
     public static final int MAX_FPS = 10;
     private static int count = 0;
 
@@ -141,4 +144,19 @@ public boolean isConnected() {
     public boolean hasConnected() {
         return true;
     }
+
+    @Override
+    public void setRecording(boolean shouldRecord) {
+        // Must NOT throw — NTDataPublisher routes recordingRequest writes through
+        // FrameProvider::setRecording on the NT listener thread, with no try/catch around
+        // the consumer. An unchecked exception here propagates into NT4's listener pool.
+        if (shouldRecord) {
+            logger.warn("Ignoring setRecording(true): FileFrameProvider does not support recording.");
+        }
+    }
+
+    @Override
+    public boolean getRecording() {
+        return false;
+    }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/frame/provider/FileLogFrameProvider.java b/photon-core/src/main/java/org/photonvision/vision/frame/provider/FileLogFrameProvider.java
new file mode 100644
index 0000000000..05a3422f11
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/frame/provider/FileLogFrameProvider.java
@@ -0,0 +1,320 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.frame.provider;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.LockSupport;
+import java.util.function.LongConsumer;
+import java.util.stream.Stream;
+import org.opencv.core.Mat;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.photonvision.common.logging.LogGroup;
+import org.photonvision.common.logging.Logger;
+import org.photonvision.vision.frame.FrameStaticProperties;
+import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.pipeline.FrameRecorder;
+
+/**
+ * Replay-side counterpart to {@link org.photonvision.vision.pipeline.FrameRecorder}. Reads a
+ * recording directory ({@code frames/<seq>.jpg} + {@code metadata.jsonl}) and emits {@link
+ * CapturedFrame}s with their original {@code capture_ns} stamped onto {@code Frame.timestampNanos}.
+ * {@link #getInputMat()} blocks the vision thread so wall-clock spacing matches the recording's
+ * {@code capture_ns} deltas.
+ *
+ * <p>At EOF the provider transitions to its stopped state and fires {@link #setOnEof onEof} once.
+ * Swap-aware consumers (see {@code VisionModule.startReplay}) wire the callback and receive empty
+ * frames after that; standalone callers (no callback) get the legacy park-until-interrupted
+ * behaviour so they don't busy-loop. Construction throws {@link IOException} if either {@code
+ * frames/000000.jpg} or {@code metadata.jsonl} is missing.
+ */
+public class FileLogFrameProvider extends CpuImageProcessor {
+    private final Path recordingDir;
+    private final Path framesDir;
+    private final MetadataSidecarReader sidecarReader;
+    private final FrameStaticProperties properties;
+    private final Logger logger;
+
+    private final AtomicBoolean stoppedAtEof = new AtomicBoolean(false);
+
+    private long emittedFrameCount = 0;
+
+    private boolean pacingAnchored = false;
+    private long firstCaptureNs;
+    private long firstMonoNs;
+
+    // Discovered at construction by listing frames/*.jpg. Used by replay UIs to render a
+    // progress bar without having to walk the directory themselves. -1 if discovery failed
+    // (logged once, treated as unknown).
+    private final long totalFrames;
+
+    // Optional hooks for replay orchestration on the consumer side. Volatile so a controller
+    // thread that wires them after construction is visible to the vision thread on next read.
+    private volatile LongConsumer onProgress;
+    private volatile Runnable onEof;
+
+    /**
+     * @param recordingDir directory containing {@code frames/} and {@code metadata.jsonl}, as written
+     *     by {@code FrameRecorder}.
+     * @throws IOException if either is missing, the first JPEG cannot be decoded, or the sidecar
+     *     cannot be read.
+     */
+    public FileLogFrameProvider(Path recordingDir) throws IOException {
+        this.recordingDir = recordingDir;
+        this.framesDir = recordingDir.resolve("frames");
+        Path metadataPath = recordingDir.resolve("metadata.jsonl");
+
+        if (!Files.isDirectory(framesDir)) {
+            throw new IOException(
+                    "Recording at " + recordingDir + " is missing the required frames/ directory.");
+        }
+        if (!Files.isRegularFile(metadataPath)) {
+            throw new IOException(
+                    "Recording at "
+                            + recordingDir
+                            + " is missing the required metadata.jsonl sidecar; without source-side"
+                            + " capture timestamps the replay timing contract cannot be honoured.");
+        }
+
+        Path firstFrame = FrameRecorder.framePath(framesDir, 0);
+        if (!Files.isRegularFile(firstFrame)) {
+            throw new IOException(
+                    "Recording at "
+                            + recordingDir
+                            + " has frames/ but is missing the first frame ("
+                            + firstFrame.getFileName()
+                            + "). The recording is empty or its file numbering doesn't start at 0.");
+        }
+        Mat probe = Imgcodecs.imread(firstFrame.toString());
+        try {
+            if (probe.empty()) {
+                throw new IOException(
+                        "First frame " + firstFrame + " could not be decoded by Imgcodecs.imread");
+            }
+            int width = probe.cols();
+            int height = probe.rows();
+            this.properties = new FrameStaticProperties(width, height, 0.0, null);
+
+            this.sidecarReader = new MetadataSidecarReader(metadataPath);
+
+            this.logger =
+                    new Logger(
+                            FileLogFrameProvider.class, recordingDir.getFileName().toString(), LogGroup.Camera);
+            this.logger.info("Opened replay source " + recordingDir + " (" + width + "x" + height + ")");
+
+            this.totalFrames = countFrames(framesDir, this.logger);
+        } finally {
+            probe.release();
+        }
+    }
+
+    private static long countFrames(Path framesDir, Logger logger) {
+        try (Stream<Path> entries = Files.list(framesDir)) {
+            return entries.filter(p -> p.getFileName().toString().endsWith(".jpg")).count();
+        } catch (IOException e) {
+            logger.warn("Failed to count frames in " + framesDir + ": " + e.getMessage());
+            return -1;
+        }
+    }
+
+    @Override
+    public CapturedFrame getInputMat() {
+        if (!cameraPropertiesCached) {
+            onCameraConnected();
+        }
+
+        if (stoppedAtEof.get()) {
+            return emptyOrPark();
+        }
+
+        Optional<MetadataSidecarReader.Entry> entry;
+        try {
+            entry = sidecarReader.readNext();
+        } catch (IOException e) {
+            logger.error(
+                    "metadata.jsonl read failed at frame "
+                            + emittedFrameCount
+                            + "; stopping at EOF: "
+                            + e.getMessage());
+            return enterStoppedState("metadata read failure");
+        }
+
+        if (entry.isEmpty()) {
+            return enterStoppedState("metadata.jsonl exhausted after " + emittedFrameCount + " frames");
+        }
+
+        long seq = entry.get().seq();
+        long captureNs = entry.get().captureNs();
+        Path framePath = FrameRecorder.framePath(framesDir, seq);
+
+        // imread returns empty Mat on missing/unreadable — covers the partial-last-frame case
+        // where the writer flushed a jsonl line then crashed mid-imwrite.
+        Mat decoded = Imgcodecs.imread(framePath.toString());
+        if (decoded.empty()) {
+            decoded.release();
+            return enterStoppedState(
+                    "frame "
+                            + framePath.getFileName()
+                            + " missing or unreadable (after "
+                            + emittedFrameCount
+                            + " frames emitted)");
+        }
+
+        pace(captureNs);
+
+        emittedFrameCount++;
+        LongConsumer progress = onProgress;
+        if (progress != null) {
+            try {
+                progress.accept(emittedFrameCount);
+            } catch (Throwable t) {
+                // Never let a misbehaving consumer break the vision thread.
+                logger.error("onProgress callback threw", t);
+            }
+        }
+        return new CapturedFrame(new CVMat(decoded), properties, captureNs);
+    }
+
+    private void pace(long captureNs) {
+        if (!pacingAnchored) {
+            firstCaptureNs = captureNs;
+            firstMonoNs = System.nanoTime();
+            pacingAnchored = true;
+            return;
+        }
+        long sleepNs = (firstMonoNs + (captureNs - firstCaptureNs)) - System.nanoTime();
+        if (sleepNs > 0) {
+            LockSupport.parkNanos(sleepNs);
+        }
+    }
+
+    public FrameStaticProperties getStaticProperties() {
+        return properties;
+    }
+
+    /**
+     * @return the recording directory this provider was constructed against (the parent of {@code
+     *     frames/} and {@code metadata.jsonl}). Used by {@code VisionSource.getReplayRecordingDir()}
+     *     to surface the current replay target without exposing the field directly.
+     */
+    public Path getRecordingDir() {
+        return recordingDir;
+    }
+
+    /**
+     * @return total frame count discovered at construction (count of {@code frames/*.jpg}), or {@code
+     *     -1} if discovery failed.
+     */
+    public long getTotalFrames() {
+        return totalFrames;
+    }
+
+    /** Fired on the vision thread after each successfully-emitted frame with the running count. */
+    public void setOnProgress(LongConsumer onProgress) {
+        this.onProgress = onProgress;
+    }
+
+    /**
+     * Fired once when the provider transitions to its stopped state — either because the recording
+     * was exhausted naturally or because {@link #requestStop()} was called. Runs on whichever thread
+     * tripped the transition; the implementation should not block.
+     *
+     * <p><strong>Wire BEFORE installing this provider on a VisionSource.</strong> The natural-EOF
+     * path fires from inside the very first {@link #getInputMat()} call on a zero-frame (or
+     * already-corrupt) recording, so a callback wired after the runner has begun pulling frames could
+     * be skipped silently — the swap-back would never run. {@code VisionModule.startReplay} preserves
+     * this ordering; future callers must do the same.
+     */
+    public void setOnEof(Runnable onEof) {
+        this.onEof = onEof;
+    }
+
+    /**
+     * Trigger an early end-of-replay from any thread. Idempotent. Once called, the next call to
+     * {@link #getInputMat()} returns an empty frame without parking (assuming {@link #setOnEof} has
+     * been wired) or parks (standalone use). Fires the EOF callback exactly once via the same CAS the
+     * natural-EOF path uses.
+     */
+    public void requestStop() {
+        enterStoppedFiringEofOnce("explicit cancel");
+    }
+
+    private CapturedFrame enterStoppedState(String reason) {
+        enterStoppedFiringEofOnce(reason);
+        return emptyOrPark();
+    }
+
+    private void enterStoppedFiringEofOnce(String reason) {
+        if (!stoppedAtEof.compareAndSet(false, true)) return;
+        logger.info("Replay reached end of recording: " + reason);
+        Runnable cb = onEof;
+        if (cb == null) return;
+        try {
+            cb.run();
+        } catch (Throwable t) {
+            logger.error("onEof callback threw", t);
+        }
+    }
+
+    // Swap-aware consumers (setOnEof wired): return an empty frame so the runner moves on.
+    // Standalone: park until interrupted, matching the legacy "deactivate to restart" semantics.
+    private CapturedFrame emptyOrPark() {
+        if (onEof == null) {
+            while (!Thread.currentThread().isInterrupted()) {
+                LockSupport.parkNanos(Long.MAX_VALUE);
+            }
+        }
+        return new CapturedFrame(new CVMat(), properties, 0L);
+    }
+
+    @Override
+    public String getName() {
+        return "FileLogFrameProvider - " + recordingDir.getFileName();
+    }
+
+    @Override
+    public void release() {
+        try {
+            sidecarReader.close();
+        } catch (IOException e) {
+            logger.warn("Failed to close metadata sidecar reader: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public boolean checkCameraConnected() {
+        return true;
+    }
+
+    @Override
+    public void setRecording(boolean shouldRecord) {
+        // Must not throw: NTDataPublisher invokes this on the NT listener thread with no
+        // try/catch around the consumer, so an unchecked exception poisons NT4's listener pool.
+        if (shouldRecord) {
+            logger.warn("Ignoring setRecording(true): file-log replay is read-only.");
+        }
+    }
+
+    @Override
+    public boolean getRecording() {
+        return false;
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/frame/provider/LibcameraGpuFrameProvider.java b/photon-core/src/main/java/org/photonvision/vision/frame/provider/LibcameraGpuFrameProvider.java
index fe7d48e6f1..a11100dd6e 100644
--- a/photon-core/src/main/java/org/photonvision/vision/frame/provider/LibcameraGpuFrameProvider.java
+++ b/photon-core/src/main/java/org/photonvision/vision/frame/provider/LibcameraGpuFrameProvider.java
@@ -164,4 +164,20 @@ protected void onCameraConnected() {
         var vidMode = settables.getCurrentVideoMode();
         settables.setVideoMode(vidMode);
     }
+
+    @Override
+    public void setRecording(boolean shouldRecord) {
+        // Must NOT throw — NTDataPublisher routes recordingRequest writes through
+        // FrameProvider::setRecording on the NT listener thread, with no try/catch around
+        // the consumer. An unchecked exception here propagates into NT4's listener pool.
+        if (shouldRecord) {
+            logger.warn(
+                    "Ignoring setRecording(true): LibcameraGpuFrameProvider does not support recording.");
+        }
+    }
+
+    @Override
+    public boolean getRecording() {
+        return false;
+    }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/frame/provider/MetadataSidecarReader.java b/photon-core/src/main/java/org/photonvision/vision/frame/provider/MetadataSidecarReader.java
new file mode 100644
index 0000000000..8f2a349950
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/frame/provider/MetadataSidecarReader.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.frame.provider;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Optional;
+
+/**
+ * Streams {@code (seq, capture_ns)} pairs out of a {@code metadata.jsonl} sidecar written by {@code
+ * FrameRecorder}. One JSON object per line, e.g. {@code {"seq":N,"capture_ns":T}}. Unknown fields
+ * are ignored so the schema can grow. Malformed lines throw {@link IOException} naming the 1-based
+ * line number.
+ */
+public class MetadataSidecarReader implements AutoCloseable {
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+
+    private final BufferedReader reader;
+    private long lineNumber = 0;
+
+    /** One (seq, capture_ns) pair from the sidecar. */
+    public record Entry(long seq, long captureNs) {}
+
+    public MetadataSidecarReader(Path jsonlPath) throws IOException {
+        this.reader = Files.newBufferedReader(jsonlPath, StandardCharsets.UTF_8);
+    }
+
+    /**
+     * Reads the next entry from the sidecar.
+     *
+     * @return the parsed entry, or {@link Optional#empty()} at end of file.
+     * @throws IOException on read failure, malformed JSON, or missing required fields. The exception
+     *     message includes the 1-based line number for diagnosis.
+     */
+    public Optional<Entry> readNext() throws IOException {
+        String line = reader.readLine();
+        if (line == null) {
+            return Optional.empty();
+        }
+        lineNumber++;
+
+        JsonNode node;
+        try {
+            node = MAPPER.readTree(line);
+        } catch (JsonProcessingException e) {
+            throw new IOException("metadata.jsonl line " + lineNumber + " is not valid JSON: " + line, e);
+        }
+
+        JsonNode seqNode = node.get("seq");
+        JsonNode captureNode = node.get("capture_ns");
+        if (seqNode == null || !seqNode.canConvertToLong()) {
+            throw new IOException(
+                    "metadata.jsonl line " + lineNumber + " missing or non-numeric 'seq': " + line);
+        }
+        if (captureNode == null || !captureNode.canConvertToLong()) {
+            throw new IOException(
+                    "metadata.jsonl line " + lineNumber + " missing or non-numeric 'capture_ns': " + line);
+        }
+
+        return Optional.of(new Entry(seqNode.asLong(), captureNode.asLong()));
+    }
+
+    @Override
+    public void close() throws IOException {
+        reader.close();
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/frame/provider/USBFrameProvider.java b/photon-core/src/main/java/org/photonvision/vision/frame/provider/USBFrameProvider.java
index 193b4c9567..6ea329a2f4 100644
--- a/photon-core/src/main/java/org/photonvision/vision/frame/provider/USBFrameProvider.java
+++ b/photon-core/src/main/java/org/photonvision/vision/frame/provider/USBFrameProvider.java
@@ -17,11 +17,18 @@
 
 package org.photonvision.vision.frame.provider;
 
+import java.nio.file.Path;
+import java.time.format.DateTimeFormatter;
 import org.opencv.core.Mat;
+import org.photonvision.common.configuration.ConfigManager;
+import org.photonvision.common.configuration.PathManager;
+import org.photonvision.common.dataflow.networktables.NetworkTablesManager;
 import org.photonvision.common.logging.LogGroup;
 import org.photonvision.common.logging.Logger;
+import org.photonvision.common.util.PathSafety;
 import org.photonvision.jni.CscoreExtras;
 import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.pipeline.FrameRecorder;
 import org.photonvision.vision.processes.VisionSourceSettables;
 import org.wpilib.util.PixelFormat;
 import org.wpilib.util.RawFrame;
@@ -79,6 +86,7 @@ public CapturedFrame getInputMat() {
                 logger.error("Error grabbing image: " + error);
             }
 
+            offerToRecorder(mat, captureTimeNs);
             return new CapturedFrame(mat, settables.getFrameStaticProperties(), captureTimeNs);
         } else {
             // We allocate memory so we don't fill a Mat in use by another thread (memory model is easier)
@@ -115,20 +123,37 @@ public CapturedFrame getInputMat() {
                 ret = new CVMat(mat, frame);
             }
 
+            offerToRecorder(ret, captureTimeUs * 1000);
             return new CapturedFrame(ret, settables.getFrameStaticProperties(), captureTimeUs * 1000);
         }
     }
 
+    // Snapshot the volatile recorder once: the NT listener thread can null it between the read
+    // and the use. recordFrame self-guards on its AtomicBooleans, so late submissions during
+    // release() drop cleanly.
+    private void offerToRecorder(CVMat mat, long captureNs) {
+        FrameRecorder rec = frameRecorder;
+        if (rec != null && rec.isRecording()) {
+            rec.recordFrame(mat, captureNs);
+        }
+    }
+
     @Override
     public String getName() {
         return "USBFrameProvider - " + cvSink.getName();
     }
 
+    // Synchronized for symmetry with setRecording: a concurrent setRecording(true) mid-
+    // construction would otherwise leave an orphan recorder (created after release saw null).
     @Override
-    public void release() {
+    public synchronized void release() {
         CameraServer.removeServer(cvSink.getName());
         cvSink.close();
         cvSink = null;
+        if (frameRecorder != null) {
+            frameRecorder.release();
+            frameRecorder = null;
+        }
     }
 
     @Override
@@ -148,4 +173,62 @@ public boolean checkCameraConnected() {
     public void updateSettables(VisionSourceSettables settables) {
         this.settables = settables;
     }
+
+    // Synchronized to serialize start/stop transitions: without it, two concurrent
+    // setRecording(true) calls can both pass the getRecording() check while frameRecorder
+    // is null, both construct a FrameRecorder, and the second assignment orphans the first
+    // (writer thread + file handles leaked forever, no path to release).
+    @Override
+    public synchronized void setRecording(boolean shouldRecord) {
+        if (shouldRecord) {
+            String camPath = settables.getConfiguration().uniqueName;
+
+            String recordingPath = NetworkTablesManager.getInstance().getMatchData();
+            if (recordingPath == null || recordingPath.isBlank()) {
+                // No match is currently active (or FMS published whitespace), use timestamp.
+                recordingPath =
+                        DateTimeFormatter.ofPattern(PathManager.LOG_DATE_TIME_FORMAT)
+                                .format(java.time.LocalDateTime.now());
+            }
+
+            // matchData is FMS-supplied and reaches us via an unauthenticated NT topic; sanitize
+            // before letting it become a path segment.
+            Path outputPath;
+            try {
+                outputPath =
+                        PathSafety.safeResolve(
+                                ConfigManager.getInstance().getRecordingsDirectory().toPath(),
+                                camPath,
+                                recordingPath);
+            } catch (SecurityException e) {
+                logger.error("Refusing to start recording at unsafe path: " + e.getMessage());
+                return;
+            }
+
+            if (frameRecorder != null && frameRecorder.isRecording()) {
+                logger.warn("Frame recorder is already recording!");
+                return;
+            }
+
+            try {
+                frameRecorder = new FrameRecorder(outputPath);
+                frameRecorder.startRecording();
+            } catch (Exception e) {
+                logger.error("Exception creating FrameRecorder", e);
+                return;
+            }
+        } else {
+            if (frameRecorder != null) {
+                frameRecorder.stopRecording();
+                frameRecorder.release();
+                frameRecorder = null;
+            }
+        }
+    }
+
+    @Override
+    public boolean getRecording() {
+        FrameRecorder rec = frameRecorder;
+        return rec != null && rec.isRecording();
+    }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/FrameRecorder.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/FrameRecorder.java
new file mode 100644
index 0000000000..5855277737
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/FrameRecorder.java
@@ -0,0 +1,437 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipeline;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfInt;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.photonvision.common.configuration.ConfigManager;
+import org.photonvision.common.hardware.HardwareManager;
+import org.photonvision.common.hardware.metrics.SystemMonitor;
+import org.photonvision.common.logging.LogGroup;
+import org.photonvision.common.logging.Logger;
+import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.opencv.Releasable;
+import org.zeroturnaround.zip.ZipUtil;
+
+/**
+ * Writes a directory of JPEG frames ({@code frames/000000.jpg, …}) plus a {@code metadata.jsonl}
+ * sidecar of per-frame {@code (seq, capture_ns)} pairs. {@code capture_ns} is the source machine's
+ * {@code wpi::nt::Now} epoch at capture, propagated verbatim through replay.
+ *
+ * <p>Metadata is flushed before its paired frame, so {@code len(metadata.jsonl) >=
+ * frame_file_count(frames/)} holds under any process crash; readers truncate jsonl to the frame
+ * directory's count. Per-frame fsync is intentionally skipped: it would blow the 33 ms budget on
+ * SD-card-class storage.
+ */
+public class FrameRecorder implements Releasable {
+    private static final int QUEUE_CAPACITY = 30; // Buffer up to 30 frames
+    private static final long MIN_DISK_SPACE_BYTES = 4L * 1024 * 1024 * 1024; // 4 GB
+    private static final String FRAME_FILENAME_FORMAT = "%06d.jpg";
+
+    /** On-disk path of the JPEG at a given sequence number under a recording's frames dir. */
+    public static Path framePath(Path framesDir, long seq) {
+        return framesDir.resolve(String.format(FRAME_FILENAME_FORMAT, seq));
+    }
+
+    private final BlockingQueue<RecordFrame> frameQueue;
+    private final Thread writerThread;
+    private final AtomicBoolean recording;
+    private final AtomicBoolean shutdown;
+    private long sequenceCounter = 0;
+
+    public enum RecordingStrategy {
+        SNAPSHOTS
+    }
+
+    public final RecordingStrategy strat;
+
+    private Logger logger;
+
+    private final Path outputPath;
+    private final Path framesDir;
+
+    // 85: ~50-150 KB/frame at 1080p; sufficient detail for AprilTag / retro / colour pipelines.
+    private static final int JPEG_QUALITY = 85;
+
+    // Initialised in ctor body after early-throw checks (see release()).
+    private final MatOfInt jpegWriteParams;
+
+    private final BufferedWriter metadataWriter;
+
+    private static class RecordFrame {
+        final Mat mat;
+        final long captureTimestampNs;
+        final long sequenceId;
+        final boolean isPoison;
+
+        RecordFrame(Mat mat, long captureTimestampNs, long sequenceId) {
+            this.mat = mat;
+            this.captureTimestampNs = captureTimestampNs;
+            this.sequenceId = sequenceId;
+            this.isPoison = false;
+        }
+
+        // Poison pill to signal shutdown
+        private RecordFrame() {
+            this.mat = null;
+            this.captureTimestampNs = 0;
+            this.sequenceId = 0;
+            this.isPoison = true;
+        }
+
+        static RecordFrame poison() {
+            return new RecordFrame();
+        }
+    }
+
+    /**
+     * Snapshot of TSS state captured at recording-start. Persisted as {@code tss.json} so the JSON
+     * exporter can later place {@code metadata.jsonl}'s local-time-base {@code capture_ns} into the
+     * TSS time base.
+     */
+    public record TssSample(boolean tssActiveAtRecord, long tssOffsetAtRecordNs) {
+        /** Sentinel meaning "no TSS info available" — used in tests and when JNI is unavailable. */
+        public static final TssSample INACTIVE = new TssSample(false, 0L);
+    }
+
+    public FrameRecorder(Path outputPath) {
+        this(
+                outputPath,
+                HardwareManager.getInstance().getRecordingStrategy(),
+                SystemMonitor.getInstance().getUsableDiskSpace(),
+                sampleTssNow());
+    }
+
+    // Package-private DI constructor: lets tests build a recorder without bringing up the
+    // HardwareManager / SystemMonitor singletons (which transitively require photontargetingJNI
+    // via NetworkTablesManager → TimeSyncClient). Pass TssSample.INACTIVE when not exercising the
+    // tss.json hand-off.
+    FrameRecorder(Path outputPath, RecordingStrategy strat, long availableSpace, TssSample tss) {
+        this.logger = new Logger(FrameRecorder.class, LogGroup.VisionModule);
+        this.strat = strat;
+
+        if (availableSpace < MIN_DISK_SPACE_BYTES) {
+            logger.error(
+                    "Low disk space available ("
+                            + availableSpace / (1024 * 1024)
+                            + " MB). FrameRecorder will not start.");
+            throw new IllegalStateException("Insufficient disk space for FrameRecorder");
+        }
+
+        logger.info("Initializing FrameRecorder with output path: " + outputPath.toString());
+        this.outputPath = outputPath;
+        this.framesDir = outputPath.resolve("frames");
+
+        try {
+            java.nio.file.Files.createDirectories(framesDir);
+        } catch (IOException e) {
+            throw new IllegalStateException("Failed to create frames directory at " + framesDir, e);
+        }
+
+        // Sidecar must open before any frame can be queued — replay needs (seq, capture_ns).
+        try {
+            this.metadataWriter =
+                    java.nio.file.Files.newBufferedWriter(
+                            outputPath.resolve("metadata.jsonl"),
+                            java.nio.charset.StandardCharsets.UTF_8,
+                            java.nio.file.StandardOpenOption.CREATE,
+                            java.nio.file.StandardOpenOption.TRUNCATE_EXISTING);
+        } catch (IOException e) {
+            throw new IllegalStateException(
+                    "Failed to open metadata sidecar at " + outputPath + "/metadata.jsonl", e);
+        }
+
+        writeTssSnapshot(tss);
+
+        // Past every early-throw — allocate the native MatOfInt last so release() can reach it.
+        this.jpegWriteParams = new MatOfInt(Imgcodecs.IMWRITE_JPEG_QUALITY, JPEG_QUALITY);
+
+        this.frameQueue = new ArrayBlockingQueue<>(QUEUE_CAPACITY);
+        this.recording = new AtomicBoolean(false);
+        this.shutdown = new AtomicBoolean(false);
+
+        // Start the writer thread
+        switch (strat) {
+            case SNAPSHOTS -> this.writerThread = new Thread(this::videoLoop, "FrameRecorder-Video");
+            default -> throw new IllegalArgumentException("Unsupported Recording Strategy: " + strat);
+        }
+        this.writerThread.setDaemon(true);
+        this.writerThread.start();
+    }
+
+    /**
+     * Sample TSS state via the live NetworkTablesManager singleton. Returns {@link
+     * TssSample#INACTIVE} if photontargetingJNI isn't loaded (tests) or TSS has never seen a pong (no
+     * robot up). The 5-second threshold is conservative: NT pings every 1s, so any value over a few
+     * seconds means a stale or never-connected client.
+     */
+    private static TssSample sampleTssNow() {
+        try {
+            var mgr = org.photonvision.common.dataflow.networktables.NetworkTablesManager.getInstance();
+            long timeSinceLastPongUs = mgr.getTimeSinceLastPong();
+            boolean active = timeSinceLastPongUs != Long.MAX_VALUE && timeSinceLastPongUs < 5_000_000L;
+            long offsetNs = mgr.getOffset() * 1_000L;
+            return new TssSample(active, offsetNs);
+        } catch (Throwable t) {
+            // JNI not loaded, NetworkTablesManager not constructed, or TimeSyncClient handle was
+            // freed — anything in the stack throws, we treat as inactive.
+            return TssSample.INACTIVE;
+        }
+    }
+
+    /**
+     * Write {@code tss.json} alongside {@code metadata.jsonl}. Consumed by {@code
+     * JsonResultExporter.readSnapshot} to shift {@code capture_ns} into the TSS time base during AKit
+     * replay. Failure is logged-and-swallowed: the recording itself still works, the exporter just
+     * falls back to UNKNOWN.
+     */
+    private void writeTssSnapshot(TssSample tss) {
+        Path tssPath = outputPath.resolve("tss.json");
+        String json =
+                "{\"tss_active_at_record\":"
+                        + tss.tssActiveAtRecord()
+                        + ",\"tss_offset_at_record_ns\":"
+                        + tss.tssOffsetAtRecordNs()
+                        + "}\n";
+        try {
+            java.nio.file.Files.write(
+                    tssPath,
+                    json.getBytes(java.nio.charset.StandardCharsets.UTF_8),
+                    java.nio.file.StandardOpenOption.CREATE,
+                    java.nio.file.StandardOpenOption.TRUNCATE_EXISTING);
+        } catch (IOException e) {
+            logger.warn("Failed to write tss snapshot to " + tssPath + ": " + e.getMessage());
+        }
+    }
+
+    /** Start recording. Frames offered after this point will be written to {@code frames/}. */
+    public boolean startRecording() {
+        if (recording.get()) {
+            return false;
+        }
+
+        recording.set(true);
+        return true;
+    }
+
+    /** Stop recording. Frames already in the queue are still flushed by the writer thread. */
+    public void stopRecording() {
+        if (!recording.get()) {
+            return;
+        }
+
+        recording.set(false);
+    }
+
+    /**
+     * Queue a frame for the writer thread. Clones the input Mat — caller retains ownership of {@code
+     * cvmat} and is responsible for releasing it.
+     *
+     * @param captureTimestampNs source-machine capture time; preserved verbatim into the sidecar.
+     * @return false if recording is off, shutting down, the queue is full, or disk is low.
+     */
+    public boolean recordFrame(CVMat cvmat, long captureTimestampNs) {
+        if (!recording.get() || shutdown.get()) {
+            return false;
+        }
+
+        // Re-check disk every 100 frames; constructor already covered seq=0.
+        if (sequenceCounter > 0 && sequenceCounter % 100 == 0) {
+            long availableSpace = SystemMonitor.getInstance().getUsableDiskSpace();
+            if (availableSpace < MIN_DISK_SPACE_BYTES) {
+                logger.error(
+                        "Low disk space available ("
+                                + availableSpace / (1024 * 1024)
+                                + " MB). Stopping FrameRecorder.");
+                stopRecording();
+                return false;
+            }
+        }
+
+        Mat clone = cvmat.getMat().clone();
+        long seq = sequenceCounter;
+        boolean added = frameQueue.offer(new RecordFrame(clone, captureTimestampNs, seq));
+
+        if (!added) {
+            clone.release();
+        }
+
+        sequenceCounter++;
+
+        return added;
+    }
+
+    /** Worker thread: encodes each BGR frame as a standalone JPEG into the frames directory. */
+    private void videoLoop() {
+        while (!shutdown.get()) {
+            try {
+                RecordFrame frame = frameQueue.take();
+
+                if (frame.isPoison) {
+                    break;
+                }
+
+                // Metadata before frame keeps the len(jsonl) >= frame_count invariant (class doc).
+                if (writeMetadataLine(frame.sequenceId, frame.captureTimestampNs)) {
+                    writeFrame(frame.sequenceId, frame.mat);
+                }
+
+                frame.mat.release();
+
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                break;
+            }
+        }
+    }
+
+    /** Stops recording on imwrite failure (disk-full / permissions / encoder error). */
+    private void writeFrame(long seq, Mat mat) {
+        Path framePath = framePath(framesDir, seq);
+        boolean ok = Imgcodecs.imwrite(framePath.toString(), mat, jpegWriteParams);
+        if (!ok) {
+            logger.error(
+                    "Imgcodecs.imwrite failed for "
+                            + framePath
+                            + " (disk full? permission denied? encoder error?); stopping recording.");
+            stopRecording();
+        }
+    }
+
+    /**
+     * Append one {@code {"seq":N,"capture_ns":T}} line, flushed per-line. Returns false on IO failure
+     * (after stopping recording so the invariant isn't broken).
+     */
+    private boolean writeMetadataLine(long sequenceId, long captureTimestampNs) {
+        try {
+            metadataWriter.write(
+                    "{\"seq\":" + sequenceId + ",\"capture_ns\":" + captureTimestampNs + "}\n");
+            metadataWriter.flush();
+            return true;
+        } catch (java.io.IOException e) {
+            logger.error("Failed to write metadata sidecar line; stopping recording: " + e.getMessage());
+            stopRecording();
+            return false;
+        }
+    }
+
+    public boolean isRecording() {
+        return recording.get();
+    }
+
+    @Override
+    public void release() {
+        if (shutdown.getAndSet(true)) {
+            return; // Already released
+        }
+
+        stopRecording();
+
+        // Send poison pill to stop writer thread
+        try {
+            frameQueue.put(RecordFrame.poison());
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+
+        try {
+            writerThread.join(1000); // Wait up to 1 second
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+
+        // Clear any remaining frames
+        RecordFrame frame;
+        while ((frame = frameQueue.poll()) != null) {
+            if (frame.mat != null) {
+                frame.mat.release();
+            }
+        }
+
+        try {
+            metadataWriter.close();
+        } catch (java.io.IOException e) {
+            logger.warn("Failed to close metadata sidecar: " + e.getMessage());
+        }
+
+        jpegWriteParams.release();
+    }
+
+    /**
+     * Export a recording.
+     *
+     * <p>Image-sequence recordings are directories ({@code frames/*.jpg} + {@code metadata.jsonl} +
+     * {@code strat}). For download convenience we zip the whole recording into a single portable
+     * file. Users who want a watchable video can run any standard tool against the zipped frame
+     * directory (e.g. ffmpeg can build an mp4 from the JPEGs offline).
+     *
+     * @param recording Path to recording directory
+     * @return Path to a unique temp file with the recording's contents zipped
+     */
+    public static File export(Path recording) throws Exception {
+        if (!Files.isDirectory(recording)) {
+            throw new IllegalStateException("Recording directory not found: " + recording);
+        }
+        File zip = Files.createTempFile(recording.getFileName().toString() + "_", ".zip").toFile();
+        ZipUtil.pack(recording.toFile(), zip);
+        return zip;
+    }
+
+    /**
+     * Export all recordings under a single camera as a zip. The zip preserves the {@code
+     * <recording>/{frames/*.jpg, metadata.jsonl}} tree, so the user can browse recordings by name
+     * after unzipping.
+     */
+    public static File exportCamera(Path cameraRecordingsDir) throws Exception {
+        if (!Files.isDirectory(cameraRecordingsDir)) {
+            throw new IllegalStateException(
+                    "Camera recordings directory not found: " + cameraRecordingsDir);
+        }
+        String prefix = cameraRecordingsDir.getFileName().toString();
+        File zip = Files.createTempFile(prefix + "_recordings_", ".zip").toFile();
+        ZipUtil.pack(cameraRecordingsDir.toFile(), zip);
+        return zip;
+    }
+
+    /**
+     * Export every recording from every camera as a single zip. Preserves the {@code
+     * <camera>/<recording>/{frames/, metadata.jsonl, strat}} tree so cameras stay grouped.
+     */
+    public static File exportAll() throws Exception {
+        Path recordingsRoot = ConfigManager.getInstance().getRecordingsDirectory().toPath();
+        File zip = Files.createTempFile("photonvision-recordings-export-", ".zip").toFile();
+        if (Files.isDirectory(recordingsRoot)) {
+            ZipUtil.pack(recordingsRoot.toFile(), zip);
+        }
+        return zip;
+    }
+
+    public static List<RecordingStrategy> getSupportedStrategies() {
+        return List.of(RecordingStrategy.SNAPSHOTS);
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/JsonResultExporter.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/JsonResultExporter.java
new file mode 100644
index 0000000000..eb6b3ddeba
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/JsonResultExporter.java
@@ -0,0 +1,278 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipeline;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.Base64;
+import java.util.Optional;
+import java.util.function.LongSupplier;
+import org.photonvision.common.dataflow.CVPipelineResultConsumer;
+import org.photonvision.common.dataflow.structures.Packet;
+import org.photonvision.common.logging.LogGroup;
+import org.photonvision.common.logging.Logger;
+import org.photonvision.common.util.math.MathUtils;
+import org.photonvision.targeting.PhotonPipelineResult;
+import org.photonvision.vision.frame.provider.MetadataSidecarReader;
+import org.photonvision.vision.pipeline.result.CVPipelineResult;
+import org.photonvision.vision.target.TrackedTarget;
+import org.wpilib.networktables.NetworkTablesJNI;
+
+/**
+ * Streams pipeline results to an ND-JSON file for offline consumption (e.g. AdvantageKit replay).
+ *
+ * <p>File shape: one header line, then one line per pipeline result. Each result line carries the
+ * raw recorded capture_ns (verbatim from {@code metadata.jsonl}) plus a base64-encoded PhotonLib
+ * {@link Packet} for lossless round-trip via {@code PhotonPipelineResult.photonStruct.unpack()}.
+ *
+ * <p>Timestamps inside the embedded packet are shifted by {@code tssOffsetAtRecordNs} so the
+ * deserialized result matches what {@code NTDataPublisher} would have published live during the
+ * original recording. The header records the same offset so consumers that prefer the raw {@code
+ * capture_ns} field can apply it themselves.
+ *
+ * <p>Not thread-safe. Exactly one VisionRunner thread should call {@link
+ * #accept(CVPipelineResult)}.
+ */
+public class JsonResultExporter implements CVPipelineResultConsumer, AutoCloseable {
+    private static final int SCHEMA_VERSION = 1;
+    private static final int INITIAL_PACKET_BYTES = 1024;
+    private static final Logger logger = new Logger(JsonResultExporter.class, LogGroup.VisionModule);
+
+    /**
+     * TSS state sampled at recording-start. Absent ({@code Optional.empty()}) when no snapshot was
+     * written — the exporter then writes nulls in the header and skips the offset shift on the
+     * embedded packet.
+     */
+    public record OffsetSnapshot(boolean tssActiveAtRecord, long tssOffsetAtRecordNs) {}
+
+    /**
+     * Inclusive capture-timestamp bounds of the recording being replayed, taken from {@code
+     * metadata.jsonl}. Used to drop result entries whose {@code capture_ns} falls outside the
+     * recording window — namely the NT4 last-published-value snapshot delivered to the subscriber at
+     * replay start, and any swap-back frame the live source emits after the replay provider EOFs.
+     */
+    public record FrameWindow(long firstCaptureNs, long lastCaptureNs) {}
+
+    /**
+     * Scan the recording's {@code metadata.jsonl} for the first and last {@code capture_ns} values.
+     * {@code FrameRecorder} writes the sidecar in capture order, so the first line is the min and the
+     * last line is the max — but we walk the whole file rather than seeking because the sidecar is
+     * small (tens of KB for hundreds of frames) and walking is robust to a hypothetical reordering.
+     *
+     * @return the bounds, or {@link Optional#empty()} when the sidecar is missing, empty, or
+     *     unreadable. A missing window degrades the exporter to its pre-fix behavior (writes every
+     *     result, including boundary noise).
+     */
+    public static Optional<FrameWindow> readFrameWindow(Path recordingDir) {
+        Path metadataPath = recordingDir.resolve("metadata.jsonl");
+        if (!Files.isRegularFile(metadataPath)) return Optional.empty();
+        try (var reader = new MetadataSidecarReader(metadataPath)) {
+            var firstOpt = reader.readNext();
+            if (firstOpt.isEmpty()) return Optional.empty();
+            long firstNs = firstOpt.get().captureNs();
+            long lastNs = firstNs;
+            Optional<MetadataSidecarReader.Entry> next;
+            while ((next = reader.readNext()).isPresent()) {
+                lastNs = next.get().captureNs();
+            }
+            return Optional.of(new FrameWindow(firstNs, lastNs));
+        } catch (IOException e) {
+            logger.error("readFrameWindow: failed to read " + metadataPath + ": " + e.getMessage());
+            return Optional.empty();
+        }
+    }
+
+    /**
+     * Read the {@code tss.json} snapshot written by {@code FrameRecorder} from a recording dir.
+     * Returns {@link Optional#empty()} if the file is missing or malformed — the latter is logged but
+     * never thrown so a corrupt snapshot doesn't block replay.
+     */
+    public static Optional<OffsetSnapshot> readSnapshot(Path recordingDir) {
+        Path tssPath = recordingDir.resolve("tss.json");
+        if (!Files.isRegularFile(tssPath)) return Optional.empty();
+        try {
+            JsonNode node = new ObjectMapper().readTree(tssPath.toFile());
+            JsonNode active = node.get("tss_active_at_record");
+            JsonNode offset = node.get("tss_offset_at_record_ns");
+            if (active == null || offset == null) return Optional.empty();
+            return Optional.of(new OffsetSnapshot(active.asBoolean(), offset.asLong()));
+        } catch (IOException e) {
+            logger.error("readSnapshot: failed to parse " + tssPath + ": " + e.getMessage());
+            return Optional.empty();
+        }
+    }
+
+    private final ObjectMapper mapper = new ObjectMapper();
+    private final Optional<OffsetSnapshot> offsetSnapshot;
+    private final Optional<FrameWindow> frameWindow;
+    private final long offsetUs;
+    private final LongSupplier nowMicrosSupplier;
+    private BufferedWriter writer;
+    private volatile boolean closed;
+    private long droppedOutOfWindow;
+
+    public JsonResultExporter(
+            Path outputFile,
+            String cameraUniqueName,
+            String recordingName,
+            CVPipelineSettings settings,
+            Optional<OffsetSnapshot> offsetSnapshot,
+            Optional<FrameWindow> frameWindow)
+            throws IOException {
+        this(
+                outputFile,
+                cameraUniqueName,
+                recordingName,
+                settings,
+                offsetSnapshot,
+                frameWindow,
+                NetworkTablesJNI::now);
+    }
+
+    JsonResultExporter(
+            Path outputFile,
+            String cameraUniqueName,
+            String recordingName,
+            CVPipelineSettings settings,
+            Optional<OffsetSnapshot> offsetSnapshot,
+            Optional<FrameWindow> frameWindow,
+            LongSupplier nowMicrosSupplier)
+            throws IOException {
+        this.offsetSnapshot = offsetSnapshot;
+        this.frameWindow = frameWindow;
+        this.nowMicrosSupplier = nowMicrosSupplier;
+        this.offsetUs = offsetSnapshot.map(s -> s.tssOffsetAtRecordNs() / 1000L).orElse(0L);
+
+        Files.createDirectories(outputFile.getParent());
+        // TRUNCATE_EXISTING + flush-per-line mirrors FrameRecorder's metadata.jsonl: each replay
+        // session overwrites a stale file rather than appending malformed multi-header content.
+        this.writer =
+                Files.newBufferedWriter(
+                        outputFile,
+                        StandardCharsets.UTF_8,
+                        StandardOpenOption.CREATE,
+                        StandardOpenOption.TRUNCATE_EXISTING);
+
+        // Close the writer on header failure so a partial-construction error doesn't leak the FD.
+        try {
+            writeHeader(cameraUniqueName, recordingName, settings);
+        } catch (IOException e) {
+            try {
+                writer.close();
+            } catch (IOException suppressed) {
+                e.addSuppressed(suppressed);
+            }
+            throw e;
+        }
+    }
+
+    private void writeHeader(
+            String cameraUniqueName, String recordingName, CVPipelineSettings settings)
+            throws IOException {
+        ObjectNode header = mapper.createObjectNode();
+        header.put("schema_version", SCHEMA_VERSION);
+        header.put("camera_unique_name", cameraUniqueName);
+        header.put("recording_name", recordingName);
+        header.put("pipeline_type", settings.pipelineType.name());
+        header.put("pipeline_hash", Integer.toHexString(settings.hashCode()));
+        if (offsetSnapshot.isPresent()) {
+            var snap = offsetSnapshot.get();
+            header.put("tss_active_at_record", snap.tssActiveAtRecord());
+            header.put("tss_offset_at_record_ns", snap.tssOffsetAtRecordNs());
+        } else {
+            header.putNull("tss_active_at_record");
+            header.putNull("tss_offset_at_record_ns");
+        }
+        writer.write(mapper.writeValueAsString(header));
+        writer.newLine();
+        writer.flush();
+    }
+
+    @Override
+    public void accept(CVPipelineResult result) {
+        if (closed) return;
+        long captureNs = result.getImageCaptureTimestampNanos();
+        // Drop results whose capture timestamp falls outside the recording's frame window —
+        // those are the NT4 last-published snapshot the subscriber receives on first attach
+        // and any post-EOF swap-back frame from the live source, neither of which belong in
+        // a replay-of-this-recording artifact.
+        if (frameWindow.isPresent()) {
+            var window = frameWindow.get();
+            if (captureNs < window.firstCaptureNs() || captureNs > window.lastCaptureNs()) {
+                droppedOutOfWindow++;
+                return;
+            }
+        }
+        try {
+            // Mirror NTDataPublisher.accept (NTDataPublisher.java:200-215): build a wire-format
+            // PhotonPipelineResult by adding the TSS offset to the local capture / publish
+            // timestamps. We use the *record-time* offset so the deserialized result matches what
+            // AKit captured live during the original match. timeSinceLastPong is not preserved
+            // per-frame; emit 0.
+            long captureMicros = MathUtils.nanosToMicros(captureNs);
+            long nowMicros = nowMicrosSupplier.getAsLong();
+
+            var photonResult =
+                    new PhotonPipelineResult(
+                            result.sequenceID,
+                            captureMicros + offsetUs,
+                            nowMicros + offsetUs,
+                            0L,
+                            TrackedTarget.simpleFromTrackedTargets(result.targets),
+                            result.multiTagResult);
+
+            Packet packet = new Packet(INITIAL_PACKET_BYTES);
+            PhotonPipelineResult.photonStruct.pack(packet, photonResult);
+            String b64 = Base64.getEncoder().encodeToString(packet.getWrittenDataCopy());
+
+            ObjectNode line = mapper.createObjectNode();
+            line.put("capture_ns", result.getImageCaptureTimestampNanos());
+            line.put("seq", result.sequenceID);
+            line.put("packet_b64", b64);
+            writer.write(mapper.writeValueAsString(line));
+            writer.newLine();
+            writer.flush();
+        } catch (IOException e) {
+            logger.error("Failed to write json result line: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public void close() {
+        if (closed) return;
+        closed = true;
+        if (droppedOutOfWindow > 0) {
+            logger.debug("Dropped " + droppedOutOfWindow + " out-of-window result(s) from json export");
+        }
+        try {
+            if (writer != null) {
+                writer.flush();
+                writer.close();
+            }
+        } catch (IOException e) {
+            logger.error("Failed to close JsonResultExporter: " + e.getMessage());
+        }
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/processes/VisionModule.java b/photon-core/src/main/java/org/photonvision/vision/processes/VisionModule.java
index d9afb714a1..2dd359a2e1 100644
--- a/photon-core/src/main/java/org/photonvision/vision/processes/VisionModule.java
+++ b/photon-core/src/main/java/org/photonvision/vision/processes/VisionModule.java
@@ -18,10 +18,16 @@
 package org.photonvision.vision.processes;
 
 import io.javalin.websocket.WsContext;
+import java.io.IOException;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.function.BiConsumer;
 import org.opencv.core.Size;
 import org.photonvision.common.configuration.CameraConfiguration;
@@ -45,9 +51,12 @@
 import org.photonvision.vision.camera.QuirkyCamera;
 import org.photonvision.vision.camera.csi.LibcameraGpuSource;
 import org.photonvision.vision.frame.Frame;
+import org.photonvision.vision.frame.FrameProvider;
 import org.photonvision.vision.frame.consumer.FileSaveFrameConsumer;
 import org.photonvision.vision.frame.consumer.MJPGFrameConsumer;
+import org.photonvision.vision.frame.provider.FileLogFrameProvider;
 import org.photonvision.vision.pipeline.AdvancedPipelineSettings;
+import org.photonvision.vision.pipeline.JsonResultExporter;
 import org.photonvision.vision.pipeline.OutputStreamPipeline;
 import org.photonvision.vision.pipeline.ReflectivePipelineSettings;
 import org.photonvision.vision.pipeline.UICalibrationData;
@@ -57,6 +66,7 @@
 import org.wpilib.math.util.Units;
 import org.wpilib.vision.camera.CameraServerJNI;
 import org.wpilib.vision.camera.VideoException;
+import org.wpilib.vision.camera.VideoMode;
 
 /**
  * This is the God Class
@@ -95,6 +105,25 @@ public class VisionModule {
     MJPGFrameConsumer inputVideoStreamer;
     MJPGFrameConsumer outputVideoStreamer;
 
+    // Lazy: built on the first pipeline result for File Log Camera sources; null otherwise.
+    // Volatile so stop() (caller thread) sees writes made by the vision thread on first frame.
+    private volatile JsonResultExporter jsonResultExporter;
+    // Latches true on first open failure so we log + skip silently rather than spamming on
+    // every subsequent frame.
+    private boolean jsonExporterDisabled;
+
+    // Replay state — all guarded by the replayLock. The active replay provider's EOF / cancel
+    // callback dispatches the swap-back onto a single-thread executor so we never run cleanup on
+    // the vision thread mid-getInputMat.
+    private final Object replayLock = new Object();
+    private volatile boolean isReplaying;
+    private volatile long replayCurrentFrame;
+    private volatile long replayTotalFrames;
+    private volatile String replayRecordingName = "";
+    private FrameProvider savedFrameProvider;
+    private FileLogFrameProvider activeReplayProvider;
+    private java.util.concurrent.ExecutorService replayWorker;
+
     boolean mismatch;
 
     public VisionModule(PipelineManager pipelineManager, VisionSource visionSource) {
@@ -132,7 +161,7 @@ public VisionModule(PipelineManager pipelineManager, VisionSource visionSource)
         changeSubscriber = new VisionModuleChangeSubscriber(this);
         this.visionRunner =
                 new VisionRunner(
-                        this.visionSource.getFrameProvider(),
+                        this.visionSource::getFrameProvider,
                         this.pipelineManager::getCurrentPipeline,
                         this::consumeResult,
                         this.cameraQuirks,
@@ -152,6 +181,8 @@ public VisionModule(PipelineManager pipelineManager, VisionSource visionSource)
                         this::setPipeline,
                         pipelineManager::getDriverMode,
                         this::setDriverMode,
+                        visionSource.getFrameProvider()::getRecording,
+                        visionSource.getFrameProvider()::setRecording,
                         this::getFPSLimit,
                         this::setFPSLimit);
         uiDataConsumer = new UIDataPublisher(visionSource.getSettables().getConfiguration().uniqueName);
@@ -163,6 +194,7 @@ public VisionModule(PipelineManager pipelineManager, VisionSource visionSource)
         addResultConsumer(
                 (result) ->
                         lastPipelineResultBestTarget = result.hasTargets() ? result.targets.get(0) : null);
+        addResultConsumer(this::teeToJsonResultExporter);
 
         // Sync VisionModule state with the first pipeline index
         setPipeline(visionSource.getSettables().getConfiguration().currentPipelineIndex);
@@ -230,6 +262,46 @@ private void recreateStreamResultConsumers() {
                 });
     }
 
+    private List<String> getRecordingsList() {
+        List<String> recordings = new ArrayList<>();
+        Path cameraRecordingDir =
+                ConfigManager.getInstance()
+                        .getRecordingsDirectory()
+                        .toPath()
+                        .resolve(visionSource.getSettables().getConfiguration().uniqueName);
+
+        if (cameraRecordingDir.toFile().exists() && cameraRecordingDir.toFile().isDirectory()) {
+            try {
+                java.nio.file.Files.list(cameraRecordingDir)
+                        .filter(java.nio.file.Files::isDirectory)
+                        .map(Path::getFileName)
+                        .map(Path::toString)
+                        .forEach(recordings::add);
+            } catch (Exception e) {
+                logger.error("Exception listing recordings", e);
+            }
+        }
+        return recordings;
+    }
+
+    /**
+     * Calculate the disk space needed for a 5-minute recording based on current settings
+     *
+     * @return space needed in megabytes
+     */
+    public int recordingSpaceNeeded() {
+        VideoMode videoMode = visionSource.getSettables().getCurrentVideoMode();
+
+        int frames = videoMode.fps * 60 * 5;
+
+        // Assume 1 byte per pixel for color image
+        int colorImageSize = videoMode.width * videoMode.height;
+
+        int totalBytes = frames * (colorImageSize);
+
+        return totalBytes / (1024 * 1024);
+    }
+
     private class StreamRunnable extends Thread {
         private final OutputStreamPipeline outputStreamPipeline;
 
@@ -283,9 +355,8 @@ public void run() {
                 }
                 if (shouldRun) {
                     try {
-                        CVPipelineResult osr = outputStreamPipeline.process(m_frame, settings, targets);
+                        outputStreamPipeline.process(m_frame, settings, targets);
                         consumeResults(m_frame, targets);
-
                     } catch (Exception e) {
                         // Never die
                         logger.error("Exception while running stream runnable!", e);
@@ -315,6 +386,27 @@ public void start() {
     }
 
     public void stop() {
+        // If a replay is in flight, end it cleanly before tearing the runner down so the
+        // saved provider is restored on the source — otherwise a subsequent start() of this
+        // module would resume against the file-log provider. cancelReplay() dispatches the
+        // swap-back to replayWorker; spin briefly so we don't race teardown against it.
+        if (isReplaying) {
+            try {
+                cancelReplay();
+                long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(3);
+                while (isReplaying && System.nanoTime() < deadline) {
+                    Thread.sleep(20);
+                }
+                if (isReplaying) {
+                    logger.warn("Replay swap-back did not complete within 3s during stop()");
+                }
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            } catch (Exception e) {
+                logger.error("Exception cancelling replay during stop()", e);
+            }
+        }
+
         visionSource.cameraConfiguration.deactivated = true;
         visionRunner.stopProcess();
 
@@ -331,11 +423,195 @@ public void stop() {
         outputVideoStreamer.close();
         inputFrameSaver.close();
         outputFrameSaver.close();
-
+        if (jsonResultExporter != null) jsonResultExporter.close();
+        synchronized (replayLock) {
+            if (replayWorker != null) {
+                replayWorker.shutdownNow();
+                replayWorker = null;
+            }
+        }
         changeSubscriberHandle.stop();
         setVisionLEDs(false);
     }
 
+    /**
+     * @return true if this module's frame provider is currently a file-log replay source.
+     */
+    public boolean isReplaying() {
+        return isReplaying;
+    }
+
+    /** Snapshot of replay progress for polling-based UIs. Zeroed when not replaying. */
+    public ReplayStatus getReplayStatus() {
+        return new ReplayStatus(
+                isReplaying, replayRecordingName, replayCurrentFrame, replayTotalFrames);
+    }
+
+    public record ReplayStatus(
+            boolean isReplaying, String recordingName, long currentFrame, long totalFrames) {}
+
+    /**
+     * Swap this module's frame provider for a {@link FileLogFrameProvider} pointed at the given
+     * recording directory. The live provider is parked (its CvSink / GPU pipe keeps its connection,
+     * but VisionRunner stops pulling from it). On EOF or {@link #cancelReplay()} the live provider is
+     * restored automatically and the file-log provider is released. Only one replay can be active at
+     * a time per module.
+     *
+     * @throws IOException if the recording dir is missing the required structure (frames/000000.jpg +
+     *     metadata.jsonl).
+     * @throws IllegalStateException if a replay is already in flight on this module.
+     */
+    public void startReplay(Path recordingDir) throws IOException {
+        synchronized (replayLock) {
+            if (isReplaying) {
+                throw new IllegalStateException(
+                        "Replay already active on " + uniqueName() + "; cancel it before starting another");
+            }
+
+            // Open the provider first — IOExceptions surface to the caller, and we release on any
+            // later failure so the sidecar reader / frame count don't leak. setOnProgress / setOnEof
+            // MUST run before setFrameProvider; otherwise a natural EOF on the very first vision-tick
+            // could fire through an unwired callback and skip the swap-back.
+            var newProvider = new FileLogFrameProvider(recordingDir);
+            try {
+                String recordingName = recordingDir.getFileName().toString();
+                this.replayCurrentFrame = 0L;
+                this.replayTotalFrames = newProvider.getTotalFrames();
+                this.replayRecordingName = recordingName;
+                // Zero-out progress topics up front so an old replay's last-frame numbers don't
+                // linger visible in NT between this call and the first frame.
+                ntConsumer.publishReplayProgress(0L, newProvider.getTotalFrames(), recordingName);
+
+                newProvider.setOnProgress(
+                        current -> {
+                            this.replayCurrentFrame = current;
+                            ntConsumer.publishReplayProgress(
+                                    current, newProvider.getTotalFrames(), recordingName);
+                        });
+                // EOF fires on the vision thread inside getInputMat. Dispatch the swap-back to a
+                // dedicated worker so the vision thread can return its empty frame and pick up the
+                // restored provider on its next tick without us holding it inside cleanup.
+                newProvider.setOnEof(() -> dispatchReplayEnded("eof"));
+
+                this.savedFrameProvider = visionSource.getFrameProvider();
+                this.activeReplayProvider = newProvider;
+                if (this.replayWorker == null) {
+                    this.replayWorker =
+                            Executors.newSingleThreadExecutor(
+                                    r -> {
+                                        Thread t = new Thread(r, "ReplayWorker - " + uniqueName());
+                                        t.setDaemon(true);
+                                        return t;
+                                    });
+                }
+
+                visionSource.setFrameProvider(newProvider);
+                this.isReplaying = true;
+                ntConsumer.publishReplayState(true);
+                logger.info(
+                        "Started replay from "
+                                + recordingDir
+                                + " ("
+                                + newProvider.getTotalFrames()
+                                + " frames)");
+            } catch (RuntimeException e) {
+                // Roll back any partial state and release the now-orphaned sidecar reader.
+                this.savedFrameProvider = null;
+                this.activeReplayProvider = null;
+                try {
+                    newProvider.release();
+                } catch (Exception releaseEx) {
+                    logger.warn(
+                            "Failed to release file-log provider after startReplay failure: "
+                                    + releaseEx.getMessage());
+                }
+                throw e;
+            }
+        }
+    }
+
+    /**
+     * Force the active replay to end. Idempotent; no-op if not replaying. The actual swap-back runs
+     * on the replay worker thread and is fenced through {@code VisionRunner.runSynchronously} so the
+     * file-log provider is only released after the vision thread has moved off it.
+     */
+    public void cancelReplay() {
+        FileLogFrameProvider provider;
+        synchronized (replayLock) {
+            if (!isReplaying || activeReplayProvider == null) return;
+            provider = activeReplayProvider;
+        }
+        // requestStop fires the EOF callback synchronously via the same CAS that the natural-EOF
+        // path uses, so dispatchReplayEnded enqueues the swap-back exactly once.
+        provider.requestStop();
+    }
+
+    private void dispatchReplayEnded(String reason) {
+        java.util.concurrent.ExecutorService worker;
+        synchronized (replayLock) {
+            worker = replayWorker;
+            if (worker == null) return;
+        }
+        try {
+            worker.submit(() -> finishReplay(reason));
+        } catch (java.util.concurrent.RejectedExecutionException ex) {
+            // The worker was shut down between snapshot and submit (e.g. stop() racing
+            // cancelReplay() from another thread). Run the cleanup inline so isReplaying still
+            // flips false and the live provider is restored.
+            logger.warn(
+                    "Replay worker rejected swap-back submit ("
+                            + reason
+                            + "); running inline: "
+                            + ex.getMessage());
+            finishReplay(reason);
+        }
+    }
+
+    private void finishReplay(String reason) {
+        FrameProvider toRestore;
+        FileLogFrameProvider toRelease;
+        synchronized (replayLock) {
+            if (!isReplaying) return;
+            toRestore = savedFrameProvider;
+            toRelease = activeReplayProvider;
+            savedFrameProvider = null;
+            activeReplayProvider = null;
+            isReplaying = false;
+        }
+
+        // Restore the live provider first so VisionRunner re-reads it on the very next tick.
+        visionSource.setFrameProvider(toRestore);
+        // Fence: the runSynchronously task is drained at the top of the runner loop, AFTER it has
+        // re-read frameSupplier.get() on the new (restored) provider. So when the future resolves,
+        // the vision thread is no longer holding a reference inside toRelease.getInputMat().
+        try {
+            visionRunner.runSynchronously(() -> {}).get(2, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            logger.warn("Interrupted while fencing replay swap-back");
+        } catch (ExecutionException | TimeoutException e) {
+            logger.warn(
+                    "Could not fence replay swap-back within 2s; releasing anyway: " + e.getMessage());
+        }
+        try {
+            toRelease.release();
+        } catch (Exception e) {
+            logger.warn("Exception releasing file-log replay provider: " + e.getMessage());
+        }
+
+        // Close + null the JSON exporter so the next replay starts fresh (commit C makes the tee
+        // observe these resets through getReplayRecordingDir()).
+        var exporter = jsonResultExporter;
+        if (exporter != null) {
+            exporter.close();
+            jsonResultExporter = null;
+        }
+        jsonExporterDisabled = false;
+
+        ntConsumer.publishReplayState(false);
+        logger.info("Replay ended (" + reason + ")");
+    }
+
     public void setFov(double fov) {
         var settables = visionSource.getSettables();
         logger.trace(() -> "Setting " + settables.getConfiguration().nickname + ") FOV (" + fov + ")");
@@ -551,6 +827,22 @@ public void setCameraNickname(String newName) {
         inputFrameSaver.updateCameraNickname(newName);
         outputFrameSaver.updateCameraNickname(newName);
 
+        // updateCameraNickname() closes + recreates every per-camera NT publisher under the new
+        // subtable, including the replay-state publishers. Re-publish current replay state so a
+        // dashboard observing /photonvision/<newName>/* doesn't see false / 0 / "" while a replay
+        // is still in flight.
+        synchronized (replayLock) {
+            if (isReplaying) {
+                ntConsumer.publishReplayState(true);
+                if (activeReplayProvider != null) {
+                    ntConsumer.publishReplayProgress(
+                            0L,
+                            activeReplayProvider.getTotalFrames(),
+                            activeReplayProvider.getRecordingDir().getFileName().toString());
+                }
+            }
+        }
+
         // Push new data to the UI
         saveAndBroadcastAll();
     }
@@ -620,6 +912,8 @@ public UICameraConfiguration toUICameraConfig() {
         ret.isConnected = visionSource.getFrameProvider().isConnected();
         ret.hasConnected = visionSource.getFrameProvider().hasConnected();
 
+        ret.recordings = getRecordingsList();
+
         return ret;
     }
 
@@ -688,6 +982,60 @@ private void consumeResults(Frame frame, List<TrackedTarget> targets) {
         }
     }
 
+    /**
+     * Tee pipeline results to a {@link JsonResultExporter} while this module's source is backed by a
+     * {@link FileLogFrameProvider} (the swap installed by {@link #startReplay}). Built lazily on the
+     * first replayed result and closed by {@code finishReplay} on swap-back; gating on the current
+     * frame provider rather than matchedCameraInfo lets the live camera's identity stay intact for
+     * the entire replay.
+     */
+    private void teeToJsonResultExporter(CVPipelineResult result) {
+        if (jsonExporterDisabled) return;
+        var replayDirOpt = visionSource.getReplayRecordingDir();
+        if (replayDirOpt.isEmpty()) return;
+        Path recordingDir = replayDirOpt.get();
+
+        if (jsonResultExporter == null) {
+            var settings = pipelineManager.getCurrentPipelineSettings();
+            if (settings == null) return; // pre-init: skip and try again on the next frame.
+
+            Path outputFile =
+                    recordingDir
+                            .resolve("results")
+                            .resolve(Integer.toHexString(settings.hashCode()) + ".jsonl");
+
+            var snapshot = JsonResultExporter.readSnapshot(recordingDir);
+            if (snapshot.isEmpty() || !snapshot.get().tssActiveAtRecord()) {
+                logger.warn(
+                        "JsonResultExporter: tss snapshot missing or inactive in "
+                                + recordingDir
+                                + " — embedded packet timestamps will not be TSS-aligned");
+            }
+
+            // Frame-window bounds drop the NT4 last-published snapshot at replay start and the
+            // swap-back frame at replay end. Falls back to no-filter when metadata.jsonl is
+            // missing/unreadable; that case is logged inside readFrameWindow.
+            var frameWindow = JsonResultExporter.readFrameWindow(recordingDir);
+
+            try {
+                jsonResultExporter =
+                        new JsonResultExporter(
+                                outputFile,
+                                visionSource.getSettables().getConfiguration().uniqueName,
+                                recordingDir.getFileName().toString(),
+                                settings,
+                                snapshot,
+                                frameWindow);
+            } catch (IOException e) {
+                logger.error("Failed to open JsonResultExporter at " + outputFile + ": " + e.getMessage());
+                jsonExporterDisabled = true; // latch: don't spam-retry on every subsequent frame.
+                return;
+            }
+        }
+
+        jsonResultExporter.accept(result);
+    }
+
     public void setTargetModel(TargetModel targetModel) {
         var pipelineSettings = pipelineManager.getCurrentPipeline().getSettings();
         if (pipelineSettings instanceof ReflectivePipelineSettings settings) {
diff --git a/photon-core/src/main/java/org/photonvision/vision/processes/VisionRunner.java b/photon-core/src/main/java/org/photonvision/vision/processes/VisionRunner.java
index f1b99d6fd9..523f1dd0d0 100644
--- a/photon-core/src/main/java/org/photonvision/vision/processes/VisionRunner.java
+++ b/photon-core/src/main/java/org/photonvision/vision/processes/VisionRunner.java
@@ -19,6 +19,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Future;
@@ -43,7 +44,9 @@
 public class VisionRunner {
     private final Logger logger;
     private final Thread visionProcessThread;
-    private final FrameProvider frameSupplier;
+    // Re-read every loop iteration so an in-place provider swap on VisionSource (live → file-log
+    // replay and back) takes effect on the next frame grab without restarting the runner.
+    private final Supplier<FrameProvider> frameSupplier;
     private final Supplier<CVPipeline> pipelineSupplier;
     private final Consumer<CVPipelineResult> pipelineResultConsumer;
     private final VisionModuleChangeSubscriber changeSubscriber;
@@ -57,12 +60,13 @@ public class VisionRunner {
      * VisionRunner contains a thread to run a pipeline, given a frame, and will give the result to
      * the consumer.
      *
-     * @param frameSupplier The supplier of the latest frame.
+     * @param frameSupplier Supplier of the active frame provider; called every loop tick so the
+     *     runner picks up provider swaps (e.g. for replay) atomically.
      * @param pipelineSupplier The supplier of the current pipeline.
      * @param pipelineResultConsumer The consumer of the latest result.
      */
     public VisionRunner(
-            FrameProvider frameSupplier,
+            Supplier<FrameProvider> frameSupplier,
             Supplier<CVPipeline> pipelineSupplier,
             Consumer<CVPipelineResult> pipelineResultConsumer,
             QuirkyCamera cameraQuirks,
@@ -75,9 +79,13 @@ public VisionRunner(
         this.changeSubscriber = changeSubscriber;
         this.fpsLimitSupplier = fpsLimitSupplier;
 
+        var initialProvider =
+                Objects.requireNonNull(
+                        frameSupplier.get(),
+                        "frame provider must be registered on the VisionSource before VisionRunner construction");
         visionProcessThread = new Thread(this::update);
-        visionProcessThread.setName("VisionRunner - " + frameSupplier.getName());
-        logger = new Logger(VisionRunner.class, frameSupplier.getName(), LogGroup.VisionModule);
+        visionProcessThread.setName("VisionRunner - " + initialProvider.getName());
+        logger = new Logger(VisionRunner.class, initialProvider.getName(), LogGroup.VisionModule);
         changeSubscriber.processSettingChanges();
     }
 
@@ -132,7 +140,7 @@ public <T> Future<T> runSynchronously(Callable<T> callable) {
 
     private void update() {
         // wait for the camera to connect
-        while (!frameSupplier.isConnected() && !Thread.interrupted()) {
+        while (!frameSupplier.get().isConnected() && !Thread.interrupted()) {
             // yield
             pipelineResultConsumer.accept(new CVPipelineResult(0l, 0, 0, null, new Frame()));
             try {
@@ -170,21 +178,25 @@ private void update() {
             // TODO would a callback object be a better fit?
             var wantedProcessType = pipeline.getThresholdType();
 
-            frameSupplier.requestFrameThresholdType(wantedProcessType);
+            // Snapshot the active provider once per tick so all per-tick requests and the frame grab
+            // target the same provider — protects against a mid-tick swap splitting setup calls
+            // across two providers.
+            var provider = frameSupplier.get();
+            provider.requestFrameThresholdType(wantedProcessType);
             var settings = pipeline.getSettings();
             if (settings instanceof AdvancedPipelineSettings advanced) {
                 var hsvParams =
                         new HSVPipe.HSVParams(
                                 advanced.hsvHue, advanced.hsvSaturation, advanced.hsvValue, advanced.hueInverted);
                 // TODO who should deal with preventing this from happening _every single loop_?
-                frameSupplier.requestHsvSettings(hsvParams);
+                provider.requestHsvSettings(hsvParams);
             }
-            frameSupplier.requestFrameRotation(settings.inputImageRotationMode);
-            frameSupplier.requestFrameCopies(settings.inputShouldShow, settings.outputShouldShow);
-            frameSupplier.requestBlockForFrames(settings.blockForFrames);
+            provider.requestFrameRotation(settings.inputImageRotationMode);
+            provider.requestFrameCopies(settings.inputShouldShow, settings.outputShouldShow);
+            provider.requestBlockForFrames(settings.blockForFrames);
 
             // Grab the new camera frame
-            var frame = frameSupplier.get();
+            var frame = provider.get();
 
             // Frame empty -- no point in trying to do anything more?
             if (frame.processedImage.getMat().empty() && frame.colorImage.getMat().empty()) {
diff --git a/photon-core/src/main/java/org/photonvision/vision/processes/VisionSource.java b/photon-core/src/main/java/org/photonvision/vision/processes/VisionSource.java
index 034e3f5f0f..cb1bd27e8f 100644
--- a/photon-core/src/main/java/org/photonvision/vision/processes/VisionSource.java
+++ b/photon-core/src/main/java/org/photonvision/vision/processes/VisionSource.java
@@ -17,13 +17,21 @@
 
 package org.photonvision.vision.processes;
 
+import java.nio.file.Path;
+import java.util.Optional;
 import org.photonvision.common.configuration.CameraConfiguration;
 import org.photonvision.vision.frame.FrameProvider;
+import org.photonvision.vision.frame.provider.FileLogFrameProvider;
 import org.photonvision.vision.opencv.Releasable;
 
 public abstract class VisionSource implements Releasable {
     protected final CameraConfiguration cameraConfiguration;
 
+    // Held volatile so a swap on a controller thread (e.g. a replay-trigger REST handler) is
+    // visible to the vision thread on its next get() — VisionRunner re-reads through
+    // getFrameProvider() every loop iteration, so the new provider takes effect on the next frame.
+    private volatile FrameProvider frameProvider;
+
     protected VisionSource(CameraConfiguration cameraConfiguration) {
         this.cameraConfiguration = cameraConfiguration;
     }
@@ -32,7 +40,32 @@ public CameraConfiguration getCameraConfiguration() {
         return cameraConfiguration;
     }
 
-    public abstract FrameProvider getFrameProvider();
+    public FrameProvider getFrameProvider() {
+        return frameProvider;
+    }
+
+    /**
+     * Atomically swap the active frame provider. Caller is responsible for the lifecycle of the
+     * outgoing provider (release / pause / restore). The vision thread reads through this getter on
+     * every loop tick, so the new provider takes effect on the next frame grab.
+     */
+    public void setFrameProvider(FrameProvider provider) {
+        this.frameProvider = provider;
+    }
+
+    /**
+     * @return the recording directory backing this source's current frame provider if it's a {@link
+     *     FileLogFrameProvider}, empty otherwise. Used to gate replay-only code paths
+     *     (JsonResultExporter tee, replay-progress publishing) on the runtime provider rather than
+     *     the matched camera info — so an in-place USB-cam → file-log swap activates them
+     *     transparently.
+     */
+    public final Optional<Path> getReplayRecordingDir() {
+        var fp = this.frameProvider;
+        return (fp instanceof FileLogFrameProvider flf)
+                ? Optional.of(flf.getRecordingDir())
+                : Optional.empty();
+    }
 
     public abstract VisionSourceSettables getSettables();
 
diff --git a/photon-core/src/test/java/org/photonvision/common/util/PathSafetyTest.java b/photon-core/src/test/java/org/photonvision/common/util/PathSafetyTest.java
new file mode 100644
index 0000000000..9a6837b7ad
--- /dev/null
+++ b/photon-core/src/test/java/org/photonvision/common/util/PathSafetyTest.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.common.util;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import org.junit.jupiter.api.Test;
+
+public class PathSafetyTest {
+    private final Path root = Paths.get(System.getProperty("java.io.tmpdir"), "pv-test-root");
+
+    @Test
+    public void validSimpleName() {
+        Path result = PathSafety.safeResolve(root, "my-camera");
+        assertEquals(root.toAbsolutePath().resolve("my-camera"), result);
+    }
+
+    @Test
+    public void validMultipleSegments() {
+        Path result = PathSafety.safeResolve(root, "camera1", "recording1");
+        assertEquals(root.toAbsolutePath().resolve("camera1").resolve("recording1"), result);
+    }
+
+    @Test
+    public void validCompositeName() {
+        // Representative of recording dir names built from match data: long, with separators,
+        // but composed only of characters legal on all target filesystems.
+        String name = "event_WEEK0_match_Q12_replay_0_station_RED1";
+        Path result = PathSafety.safeResolve(root, name);
+        assertEquals(root.toAbsolutePath().resolve(name), result);
+    }
+
+    @Test
+    public void rejectsFilesystemIllegalChars() {
+        // On Windows, ':' is reserved for drive letters and the JDK throws InvalidPathException
+        // at resolve-time. The util wraps that as SecurityException so the caller sees one type.
+        // (This test is a no-op on POSIX, where ':' is a legal filename char — the call simply
+        // returns a valid Path; we don't assertThrows here to keep the test cross-platform.)
+        try {
+            PathSafety.safeResolve(root, "name:with:colons");
+            // POSIX: accepted, fine.
+        } catch (SecurityException e) {
+            // Windows: wrapped as SecurityException, also fine.
+        }
+    }
+
+    @Test
+    public void rejectsDoubleDot() {
+        assertThrows(SecurityException.class, () -> PathSafety.safeResolve(root, ".."));
+    }
+
+    @Test
+    public void rejectsParentTraversal() {
+        assertThrows(SecurityException.class, () -> PathSafety.safeResolve(root, "../etc"));
+    }
+
+    @Test
+    public void rejectsEmbeddedTraversal() {
+        assertThrows(SecurityException.class, () -> PathSafety.safeResolve(root, "a/../../etc"));
+    }
+
+    @Test
+    public void rejectsAbsolutePosixPath() {
+        // resolve(absolute) returns the absolute path, which won't startWith(root)
+        assertThrows(SecurityException.class, () -> PathSafety.safeResolve(root, "/etc/passwd"));
+    }
+
+    @Test
+    public void rejectsTraversalAcrossSegments() {
+        // valid first segment, escape attempt in the second
+        assertThrows(
+                SecurityException.class, () -> PathSafety.safeResolve(root, "camera1", "../../etc"));
+    }
+
+    @Test
+    public void rejectsNullSegment() {
+        assertThrows(SecurityException.class, () -> PathSafety.safeResolve(root, (String) null));
+    }
+
+    @Test
+    public void rejectsBlankSegment() {
+        assertThrows(SecurityException.class, () -> PathSafety.safeResolve(root, "   "));
+    }
+
+    @Test
+    public void rejectsEmptySegment() {
+        assertThrows(SecurityException.class, () -> PathSafety.safeResolve(root, ""));
+    }
+}
diff --git a/photon-core/src/test/java/org/photonvision/vision/frame/provider/FileLogFrameProviderTest.java b/photon-core/src/test/java/org/photonvision/vision/frame/provider/FileLogFrameProviderTest.java
new file mode 100644
index 0000000000..c7a0b5e7f4
--- /dev/null
+++ b/photon-core/src/test/java/org/photonvision/vision/frame/provider/FileLogFrameProviderTest.java
@@ -0,0 +1,339 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.frame.provider;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Scalar;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.photonvision.jni.LibraryLoader;
+import org.photonvision.vision.frame.provider.CpuImageProcessor.CapturedFrame;
+import org.photonvision.vision.pipeline.FrameRecorder;
+
+/**
+ * Synthesises a 3-frame image-sequence fixture via {@link Imgcodecs#imwrite} (the same encoder path
+ * {@code FrameRecorder} uses) and walks it through {@link FileLogFrameProvider}. Needs OpenCV but
+ * not {@code photontargetingJNI}, so runs on any platform.
+ */
+class FileLogFrameProviderTest {
+    private static final int WIDTH = 64;
+    private static final int HEIGHT = 48;
+    private static final long[] CAPTURE_NS = {1_000_000_000L, 1_033_333_333L, 1_066_666_666L};
+
+    @TempDir static Path sharedTempDir;
+    static Path recordingDir;
+
+    @BeforeAll
+    static void setUp() throws IOException {
+        if (!LibraryLoader.loadWpiLibraries()) {
+            fail("Failed to load WPI / OpenCV native libraries");
+        }
+
+        recordingDir = sharedTempDir.resolve("rec");
+        Files.createDirectories(recordingDir);
+
+        synthesizeFrames(recordingDir.resolve("frames"));
+        writeSidecar(recordingDir.resolve("metadata.jsonl"));
+    }
+
+    private static void synthesizeFrames(Path framesDir) throws IOException {
+        Files.createDirectories(framesDir);
+        for (int i = 0; i < CAPTURE_NS.length; i++) {
+            Mat frame = new Mat(HEIGHT, WIDTH, CvType.CV_8UC3, new Scalar(i * 64 % 255, 64, 128));
+            try {
+                Path out = FrameRecorder.framePath(framesDir, i);
+                assertTrue(Imgcodecs.imwrite(out.toString(), frame), "Imgcodecs.imwrite failed for " + out);
+            } finally {
+                frame.release();
+            }
+        }
+    }
+
+    private static void writeSidecar(Path out) throws IOException {
+        try (BufferedWriter w = Files.newBufferedWriter(out, StandardCharsets.UTF_8)) {
+            for (int i = 0; i < CAPTURE_NS.length; i++) {
+                w.write("{\"seq\":" + i + ",\"capture_ns\":" + CAPTURE_NS[i] + "}\n");
+            }
+        }
+    }
+
+    @Test
+    void emitsFramesWithCaptureTimestamps() throws IOException {
+        FileLogFrameProvider provider = new FileLogFrameProvider(recordingDir);
+        try {
+            assertTrue(provider.isConnected(), "should be connected before any frames emitted");
+            assertTrue(
+                    provider.hasConnected(),
+                    "isConnected() should have flipped cameraPropertiesCached on first call");
+
+            for (int i = 0; i < CAPTURE_NS.length; i++) {
+                var captured = provider.getInputMat();
+                assertNotNull(captured.colorImage, "frame " + i + ": colorImage null");
+                assertFalse(
+                        captured.colorImage.getMat().empty(),
+                        "frame " + i + ": Mat was empty (decoder failed?)");
+                assertEquals(WIDTH, captured.colorImage.getMat().cols(), "frame " + i + ": width mismatch");
+                assertEquals(
+                        HEIGHT, captured.colorImage.getMat().rows(), "frame " + i + ": height mismatch");
+                assertEquals(
+                        3, captured.colorImage.getMat().channels(), "frame " + i + ": expected 3-channel BGR");
+                assertEquals(
+                        CAPTURE_NS[i],
+                        captured.captureTimestamp,
+                        "frame " + i + ": captureTimestamp must be source-side capture_ns verbatim");
+
+                captured.colorImage.release();
+            }
+
+            // After EOF the provider parks the vision thread instead of disconnecting — the
+            // MJPEG stream holds whatever the browser last received, the pipeline stops running,
+            // and the "Frames Processed" counter freezes. To restart the user deactivates and
+            // reactivates the camera. See parksTheVisionThreadAtEof below for the wake-on-interrupt
+            // contract; here we just verify isConnected stays true past EOF.
+            assertTrue(provider.isConnected(), "replay source should stay connected after EOF");
+        } finally {
+            provider.release();
+        }
+    }
+
+    @Test
+    void parksTheVisionThreadAtEof() throws Exception {
+        // After consuming the recording, getInputMat must block until interrupted (mirroring
+        // VisionRunner.stopProcess's path) so the pipeline stops running on deactivation rather
+        // than spinning on a frozen frame. Run getInputMat on a separate thread, confirm it
+        // blocks, then interrupt it and verify it wakes with an empty CVMat + preserved flag.
+        FileLogFrameProvider provider = new FileLogFrameProvider(recordingDir);
+        try {
+            // Burn through all frames so the next call hits EOF.
+            for (int i = 0; i < CAPTURE_NS.length; i++) {
+                provider.getInputMat().colorImage.release();
+            }
+
+            java.util.concurrent.atomic.AtomicReference<CapturedFrame> result =
+                    new java.util.concurrent.atomic.AtomicReference<>();
+            java.util.concurrent.atomic.AtomicBoolean interruptedAfter =
+                    new java.util.concurrent.atomic.AtomicBoolean();
+            Thread t =
+                    new Thread(
+                            () -> {
+                                result.set(provider.getInputMat());
+                                interruptedAfter.set(Thread.currentThread().isInterrupted());
+                            });
+            t.setName("parksTheVisionThreadAtEof-runner");
+            t.start();
+
+            Thread.sleep(250); // give it time to enter the park
+            assertTrue(t.isAlive(), "getInputMat should park after EOF, not return");
+
+            t.interrupt();
+            t.join(2_000);
+            assertFalse(t.isAlive(), "getInputMat should wake within 2s of interrupt");
+
+            CapturedFrame captured = result.get();
+            assertNotNull(captured, "returned CapturedFrame should not be null");
+            assertTrue(
+                    captured.colorImage.getMat().empty(),
+                    "post-interrupt CapturedFrame should carry an empty Mat");
+            assertTrue(
+                    interruptedAfter.get(),
+                    "interrupt flag must be preserved so VisionRunner's outer loop exits cleanly");
+            captured.colorImage.release();
+        } finally {
+            provider.release();
+        }
+    }
+
+    @Test
+    void refusesRecordingMissingSidecar(@TempDir Path tmp) throws IOException {
+        Path dir = tmp.resolve("no-sidecar");
+        Files.createDirectories(dir.resolve("frames"));
+        Files.copy(
+                recordingDir.resolve("frames").resolve("000000.jpg"),
+                dir.resolve("frames").resolve("000000.jpg"));
+
+        IOException ex = assertThrows(IOException.class, () -> new FileLogFrameProvider(dir));
+        assertTrue(ex.getMessage().toLowerCase().contains("metadata.jsonl"), ex.getMessage());
+    }
+
+    @Test
+    void refusesMissingFrames(@TempDir Path tmp) throws IOException {
+        Path dir = tmp.resolve("no-frames");
+        Files.createDirectories(dir);
+        Files.writeString(dir.resolve("metadata.jsonl"), "{\"seq\":0,\"capture_ns\":1}\n");
+
+        IOException ex = assertThrows(IOException.class, () -> new FileLogFrameProvider(dir));
+        assertTrue(ex.getMessage().toLowerCase().contains("frames"), ex.getMessage());
+    }
+
+    @Test
+    void refusesEmptyFramesDir(@TempDir Path tmp) throws IOException {
+        Path dir = tmp.resolve("empty-frames");
+        Files.createDirectories(dir.resolve("frames"));
+        Files.writeString(dir.resolve("metadata.jsonl"), "{\"seq\":0,\"capture_ns\":1}\n");
+
+        IOException ex = assertThrows(IOException.class, () -> new FileLogFrameProvider(dir));
+        assertTrue(ex.getMessage().toLowerCase().contains("missing"), ex.getMessage());
+    }
+
+    @Test
+    void getTotalFramesMatchesFixture() throws IOException {
+        FileLogFrameProvider provider = new FileLogFrameProvider(recordingDir);
+        try {
+            assertEquals(
+                    CAPTURE_NS.length,
+                    provider.getTotalFrames(),
+                    "totalFrames must reflect the on-disk frames/*.jpg count");
+        } finally {
+            provider.release();
+        }
+    }
+
+    @Test
+    void onProgressFiresOncePerEmittedFrame() throws IOException {
+        FileLogFrameProvider provider = new FileLogFrameProvider(recordingDir);
+        try {
+            java.util.List<Long> seen = new java.util.concurrent.CopyOnWriteArrayList<>();
+            provider.setOnProgress(seen::add);
+
+            for (int i = 0; i < CAPTURE_NS.length; i++) {
+                provider.getInputMat().colorImage.release();
+            }
+
+            assertEquals(CAPTURE_NS.length, seen.size(), "one callback per emitted frame");
+            for (int i = 0; i < seen.size(); i++) {
+                assertEquals(
+                        (long) (i + 1),
+                        (long) seen.get(i),
+                        "callback arg should be the running 1-based emitted-frame count");
+            }
+        } finally {
+            provider.release();
+        }
+    }
+
+    @Test
+    void onEofFiresOnceOnNaturalExhaustion() throws IOException {
+        FileLogFrameProvider provider = new FileLogFrameProvider(recordingDir);
+        try {
+            java.util.concurrent.atomic.AtomicInteger fired =
+                    new java.util.concurrent.atomic.AtomicInteger();
+            provider.setOnEof(fired::incrementAndGet);
+
+            // Burn through all frames.
+            for (int i = 0; i < CAPTURE_NS.length; i++) {
+                provider.getInputMat().colorImage.release();
+            }
+            assertEquals(0, fired.get(), "onEof must not fire while frames remain");
+
+            // Next read exhausts metadata.jsonl → enters stopped state, fires callback exactly once.
+            provider.getInputMat().colorImage.release();
+            assertEquals(1, fired.get(), "onEof must fire on natural exhaustion");
+
+            // Subsequent reads must not fire it again.
+            provider.getInputMat().colorImage.release();
+            provider.getInputMat().colorImage.release();
+            assertEquals(1, fired.get(), "onEof must be one-shot");
+        } finally {
+            provider.release();
+        }
+    }
+
+    @Test
+    void requestStopShortCircuitsAndFiresEofOnce() throws IOException {
+        FileLogFrameProvider provider = new FileLogFrameProvider(recordingDir);
+        try {
+            java.util.concurrent.atomic.AtomicInteger fired =
+                    new java.util.concurrent.atomic.AtomicInteger();
+            provider.setOnEof(fired::incrementAndGet);
+
+            provider.requestStop();
+            assertEquals(1, fired.get(), "requestStop must fire onEof synchronously");
+
+            // Next getInputMat should return an empty frame (callback wired ⇒ no parking).
+            var captured = provider.getInputMat();
+            assertTrue(
+                    captured.colorImage.getMat().empty(),
+                    "after requestStop, getInputMat must return empty for swap-aware consumers");
+            captured.colorImage.release();
+
+            // Second requestStop is a no-op via the CAS.
+            provider.requestStop();
+            assertEquals(1, fired.get(), "requestStop must be idempotent");
+        } finally {
+            provider.release();
+        }
+    }
+
+    @Test
+    void eofWithoutCallbackPreservesParkingBehaviour() throws Exception {
+        // Standalone use (no setOnEof): the original "park on EOF, deactivate to restart" semantics
+        // must be preserved so non-swap-aware consumers don't busy-loop on empties.
+        FileLogFrameProvider provider = new FileLogFrameProvider(recordingDir);
+        try {
+            for (int i = 0; i < CAPTURE_NS.length; i++) {
+                provider.getInputMat().colorImage.release();
+            }
+
+            Thread t =
+                    new Thread(
+                            () -> {
+                                provider.getInputMat().colorImage.release();
+                            });
+            t.setName("eofWithoutCallback-runner");
+            t.start();
+            Thread.sleep(150);
+            assertTrue(t.isAlive(), "no callback wired ⇒ should park at EOF, not return");
+            t.interrupt();
+            t.join(2_000);
+            assertFalse(t.isAlive(), "interrupt must wake the parked thread");
+        } finally {
+            provider.release();
+        }
+    }
+
+    @Test
+    void setRecordingIsNoOp() throws IOException {
+        // setRecording is invoked by the NT listener thread (NTDataPublisher routes
+        // recordingRequest writes through FrameProvider::setRecording with no try/catch).
+        // Replay sources must not throw — they silently ignore the request and stay false.
+        FileLogFrameProvider provider = new FileLogFrameProvider(recordingDir);
+        try {
+            provider.setRecording(true);
+            assertFalse(provider.getRecording());
+            provider.setRecording(false);
+            assertFalse(provider.getRecording());
+        } finally {
+            provider.release();
+        }
+    }
+}
diff --git a/photon-core/src/test/java/org/photonvision/vision/frame/provider/MetadataSidecarReaderTest.java b/photon-core/src/test/java/org/photonvision/vision/frame/provider/MetadataSidecarReaderTest.java
new file mode 100644
index 0000000000..2cfad9a990
--- /dev/null
+++ b/photon-core/src/test/java/org/photonvision/vision/frame/provider/MetadataSidecarReaderTest.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.frame.provider;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Optional;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+/**
+ * Unit tests for {@link MetadataSidecarReader}. Pure JVM — no OpenCV, no JNI, runs anywhere.
+ *
+ * <p>The fixture format mirrors what {@code FrameRecorder.writeMetadataLine} writes: {@code
+ * "{\"seq\":N,\"capture_ns\":T}\n"} — note the trailing newline on every line including the last,
+ * so a sane file ends with an empty segment after the final {@code \n}.
+ */
+class MetadataSidecarReaderTest {
+    @TempDir Path tempDir;
+
+    private Path write(String contents) throws IOException {
+        Path p = tempDir.resolve("metadata.jsonl");
+        Files.writeString(p, contents, StandardCharsets.UTF_8);
+        return p;
+    }
+
+    @Test
+    void readsKnownFields() throws IOException {
+        Path p = write("{\"seq\":0,\"capture_ns\":1000}\n" + "{\"seq\":1,\"capture_ns\":1033333}\n");
+        try (var reader = new MetadataSidecarReader(p)) {
+            var first = reader.readNext();
+            assertTrue(first.isPresent());
+            assertEquals(0L, first.get().seq());
+            assertEquals(1000L, first.get().captureNs());
+
+            var second = reader.readNext();
+            assertTrue(second.isPresent());
+            assertEquals(1L, second.get().seq());
+            assertEquals(1033333L, second.get().captureNs());
+
+            assertEquals(Optional.empty(), reader.readNext());
+        }
+    }
+
+    @Test
+    void ignoresUnknownFields() throws IOException {
+        // Schema is forward-compatible: future writers may add exposure_us, gain_db, calibration
+        // version. Reader must ignore them and still produce the correct seq/capture_ns.
+        Path p =
+                write(
+                        "{\"seq\":5,\"capture_ns\":42,\"exposure_us\":1200,"
+                                + "\"gain_db\":3.5,\"calibration_version\":\"v2\"}\n");
+        try (var reader = new MetadataSidecarReader(p)) {
+            var entry = reader.readNext();
+            assertTrue(entry.isPresent());
+            assertEquals(5L, entry.get().seq());
+            assertEquals(42L, entry.get().captureNs());
+        }
+    }
+
+    @Test
+    void handlesTrailingNewline() throws IOException {
+        // FrameRecorder always writes "...}\n" so the file ends with an empty segment after the
+        // final newline. That must read as EOF, not produce an error.
+        Path p = write("{\"seq\":0,\"capture_ns\":1}\n");
+        try (var reader = new MetadataSidecarReader(p)) {
+            assertTrue(reader.readNext().isPresent());
+            assertEquals(Optional.empty(), reader.readNext());
+        }
+    }
+
+    @Test
+    void emptyFileIsEof() throws IOException {
+        Path p = write("");
+        try (var reader = new MetadataSidecarReader(p)) {
+            assertEquals(Optional.empty(), reader.readNext());
+        }
+    }
+
+    @Test
+    void failsOnMissingFields() throws IOException {
+        try (var reader = new MetadataSidecarReader(write("{\"capture_ns\":123}\n"))) {
+            IOException ex = assertThrows(IOException.class, reader::readNext);
+            assertTrue(ex.getMessage().contains("line 1") && ex.getMessage().contains("seq"));
+        }
+        try (var reader = new MetadataSidecarReader(write("{\"seq\":1}\n"))) {
+            IOException ex = assertThrows(IOException.class, reader::readNext);
+            assertTrue(ex.getMessage().contains("line 1") && ex.getMessage().contains("capture_ns"));
+        }
+    }
+
+    @Test
+    void failsOnMalformedJson() throws IOException {
+        try (var reader = new MetadataSidecarReader(write("{seq:1,capture_ns:2\n"))) {
+            IOException ex = assertThrows(IOException.class, reader::readNext);
+            assertTrue(ex.getMessage().contains("line 1"));
+            assertTrue(ex.getMessage().toLowerCase().contains("json"));
+        }
+    }
+
+    @Test
+    void missingFileFailsAtConstruction() {
+        assertThrows(
+                IOException.class,
+                () -> new MetadataSidecarReader(tempDir.resolve("does-not-exist.jsonl")));
+    }
+}
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/FrameRecorderIntegrationTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/FrameRecorderIntegrationTest.java
new file mode 100644
index 0000000000..43fda2b1df
--- /dev/null
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/FrameRecorderIntegrationTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipeline;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import java.io.BufferedReader;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Scalar;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.photonvision.jni.LibraryLoader;
+import org.photonvision.vision.opencv.CVMat;
+
+/**
+ * Round-trips 60 synthetic frames through {@link FrameRecorder} and decodes each back with {@link
+ * Imgcodecs} — the same decoder path {@code FileLogFrameProvider} uses on replay. Uses the
+ * package-private DI ctor so it doesn't need {@code photontargetingJNI}.
+ */
+public class FrameRecorderIntegrationTest {
+    private static final int W = 640;
+    private static final int H = 480;
+    private static final int FRAME_COUNT = 60;
+
+    @BeforeAll
+    static void init() {
+        // OpenCV + WPI bits we need (HAL, NT JNI not actually used because the DI ctor bypasses
+        // singletons). loadTargeting() is intentionally skipped.
+        if (!LibraryLoader.loadWpiLibraries()) fail("loadWpiLibraries() returned false");
+    }
+
+    @Test
+    public void recordsSyntheticFramesIntoJpegSequence(@TempDir Path tempDir) throws Exception {
+        Path outDir = tempDir.resolve("rec1");
+        Files.createDirectories(outDir);
+
+        FrameRecorder recorder =
+                new FrameRecorder(
+                        outDir,
+                        FrameRecorder.RecordingStrategy.SNAPSHOTS,
+                        Long.MAX_VALUE,
+                        FrameRecorder.TssSample.INACTIVE);
+        try {
+            assertTrue(recorder.startRecording(), "startRecording() should succeed first call");
+
+            long baseNs = 1_000_000_000L; // pretend wall-clock origin
+            for (int i = 0; i < FRAME_COUNT; i++) {
+                // Solid-color BGR frame that shifts each frame so the encoder sees real motion.
+                Mat mat = new Mat(H, W, CvType.CV_8UC3, new Scalar(i * 4 % 255, 64, 128));
+                CVMat cv = new CVMat(mat);
+
+                long captureNs = baseNs + i * 33_333_333L; // 30fps cadence
+                boolean queued = recorder.recordFrame(cv, captureNs);
+                assertTrue(queued, "frame " + i + " not queued");
+
+                // Confirm clone semantics: caller's Mat is still alive after recordFrame.
+                assertTrue(!mat.empty(), "caller's mat was released by recordFrame (use-after-free)");
+
+                cv.release(); // releases caller's Mat (mirrors real pipeline behavior)
+
+                // Pace slower than the 30-deep queue can encode (~5ms each = ~300ms total).
+                Thread.sleep(5);
+            }
+        } finally {
+            recorder.release();
+        }
+
+        // --- Assertions on disk artifacts ---
+        Path framesDir = outDir.resolve("frames");
+        Path meta = outDir.resolve("metadata.jsonl");
+
+        assertTrue(Files.isDirectory(framesDir), "frames/ directory missing");
+        assertTrue(Files.exists(meta), "metadata.jsonl missing");
+
+        for (int i = 0; i < FRAME_COUNT; i++) {
+            Path framePath = FrameRecorder.framePath(framesDir, i);
+            assertTrue(Files.exists(framePath), "frame " + i + " missing: " + framePath);
+            assertTrue(Files.size(framePath) > 0, "frame " + i + " is empty");
+
+            Mat decoded = Imgcodecs.imread(framePath.toString());
+            try {
+                assertFalse(decoded.empty(), "frame " + i + " decoded empty");
+                assertEquals(W, decoded.cols(), "frame " + i + ": width mismatch");
+                assertEquals(H, decoded.rows(), "frame " + i + ": height mismatch");
+                assertEquals(3, decoded.channels(), "frame " + i + ": expected BGR (3 channels)");
+            } finally {
+                decoded.release();
+            }
+        }
+
+        List<String> lines;
+        try (BufferedReader r = Files.newBufferedReader(meta, StandardCharsets.UTF_8)) {
+            lines = r.lines().toList();
+        }
+        assertTrue(
+                lines.size() >= FRAME_COUNT,
+                "metadata.jsonl line count " + lines.size() + " < frame count " + FRAME_COUNT);
+        for (int i = 0; i < FRAME_COUNT; i++) {
+            String expected =
+                    "{\"seq\":" + i + ",\"capture_ns\":" + (1_000_000_000L + i * 33_333_333L) + "}";
+            assertEquals(expected, lines.get(i), "metadata line " + i + " mismatch");
+        }
+    }
+}
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/FrameRecorderTssSnapshotTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/FrameRecorderTssSnapshotTest.java
new file mode 100644
index 0000000000..c211e7836e
--- /dev/null
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/FrameRecorderTssSnapshotTest.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipeline;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.photonvision.jni.LibraryLoader;
+import org.photonvision.vision.pipeline.FrameRecorder.TssSample;
+
+/**
+ * Verifies the tss.json hand-off between FrameRecorder (writer) and JsonResultExporter (reader).
+ * The two sides only share a JSON key contract — no shared Java type — so this test validates both
+ * ends round-trip cleanly.
+ */
+public class FrameRecorderTssSnapshotTest {
+    @BeforeAll
+    static void init() {
+        // FrameRecorder ctor allocates a MatOfInt → OpenCV native dep, same as the integration
+        // test in this package.
+        if (!LibraryLoader.loadWpiLibraries()) fail("loadWpiLibraries() returned false");
+    }
+
+    @Test
+    public void writesActiveSnapshot(@TempDir Path tempDir) throws Exception {
+        Path outDir = tempDir.resolve("rec");
+        Files.createDirectories(outDir);
+        var sample = new TssSample(true, 4_500_000L);
+
+        var recorder =
+                new FrameRecorder(
+                        outDir, FrameRecorder.RecordingStrategy.SNAPSHOTS, Long.MAX_VALUE, sample);
+        try {
+            // Snapshot is written in the constructor — no need to startRecording / record frames.
+        } finally {
+            recorder.release();
+        }
+
+        Path tssPath = outDir.resolve("tss.json");
+        assertTrue(Files.exists(tssPath), "tss.json should exist after ctor");
+        JsonNode node = new ObjectMapper().readTree(tssPath.toFile());
+        assertTrue(node.get("tss_active_at_record").asBoolean());
+        assertEquals(4_500_000L, node.get("tss_offset_at_record_ns").asLong());
+    }
+
+    @Test
+    public void writesInactiveSentinel(@TempDir Path tempDir) throws Exception {
+        Path outDir = tempDir.resolve("rec");
+        Files.createDirectories(outDir);
+
+        var recorder =
+                new FrameRecorder(
+                        outDir, FrameRecorder.RecordingStrategy.SNAPSHOTS, Long.MAX_VALUE, TssSample.INACTIVE);
+        try {
+            // No frames needed: writeTssSnapshot runs in the constructor.
+        } finally {
+            recorder.release();
+        }
+
+        JsonNode node = new ObjectMapper().readTree(outDir.resolve("tss.json").toFile());
+        assertFalse(node.get("tss_active_at_record").asBoolean());
+        assertEquals(0L, node.get("tss_offset_at_record_ns").asLong());
+    }
+
+    @Test
+    public void readSnapshotReturnsPopulatedFromWrittenFile(@TempDir Path tempDir) throws Exception {
+        Path outDir = tempDir.resolve("rec");
+        Files.createDirectories(outDir);
+        var sample = new TssSample(true, 7_200_000L);
+
+        var recorder =
+                new FrameRecorder(
+                        outDir, FrameRecorder.RecordingStrategy.SNAPSHOTS, Long.MAX_VALUE, sample);
+        recorder.release();
+
+        var snap = JsonResultExporter.readSnapshot(outDir);
+        assertTrue(snap.isPresent());
+        assertTrue(snap.get().tssActiveAtRecord());
+        assertEquals(7_200_000L, snap.get().tssOffsetAtRecordNs());
+    }
+
+    @Test
+    public void readSnapshotReturnsUnknownWhenFileMissing(@TempDir Path tempDir) {
+        // tempDir has no tss.json.
+        assertTrue(JsonResultExporter.readSnapshot(tempDir).isEmpty());
+    }
+
+    @Test
+    public void readSnapshotReturnsUnknownOnMalformedJson(@TempDir Path tempDir) throws Exception {
+        Files.write(tempDir.resolve("tss.json"), "{not valid json".getBytes(StandardCharsets.UTF_8));
+
+        assertTrue(JsonResultExporter.readSnapshot(tempDir).isEmpty());
+    }
+
+    @Test
+    public void readSnapshotReturnsUnknownOnMissingKeys(@TempDir Path tempDir) throws Exception {
+        Files.write(
+                tempDir.resolve("tss.json"), "{\"some_other_field\":42}".getBytes(StandardCharsets.UTF_8));
+
+        assertTrue(JsonResultExporter.readSnapshot(tempDir).isEmpty());
+    }
+}
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/JsonResultEndToEndTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/JsonResultEndToEndTest.java
new file mode 100644
index 0000000000..e906547535
--- /dev/null
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/JsonResultEndToEndTest.java
@@ -0,0 +1,254 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipeline;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+import java.util.Optional;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Scalar;
+import org.photonvision.common.dataflow.structures.Packet;
+import org.photonvision.jni.LibraryLoader;
+import org.photonvision.targeting.MultiTargetPNPResult;
+import org.photonvision.targeting.PhotonPipelineResult;
+import org.photonvision.targeting.PnpResult;
+import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.pipeline.result.CVPipelineResult;
+import org.wpilib.math.geometry.Rotation3d;
+import org.wpilib.math.geometry.Transform3d;
+import org.wpilib.math.geometry.Translation3d;
+
+/**
+ * End-to-end determinism verification. Records a synthetic recording with a known TSS snapshot,
+ * then runs two exporter passes (different "settings") against pipeline results whose timestamps
+ * are pulled straight from the recording's metadata.jsonl. Verifies the two contracts the AKit
+ * consumer relies on:
+ *
+ * <ol>
+ *   <li>No tuning change ⇒ same {@code capture_ns} sequence in JSON as in the recording's
+ *       metadata.jsonl, byte-for-byte deterministic given a fixed publish clock.
+ *   <li>Tuning change ⇒ same {@code capture_ns} sequence but different result payloads + a
+ *       different output filename (per-pipeline-hash isolation).
+ * </ol>
+ *
+ * <p>FileLogFrameProvider's metadata round-trip is verified separately by {@code
+ * FileLogFrameProviderTest.emitsFramesWithCaptureTimestamps}; here we read {@code metadata.jsonl}
+ * directly to keep the test in the {@code vision.pipeline} package.
+ */
+public class JsonResultEndToEndTest {
+    private static final int W = 64;
+    private static final int H = 48;
+    private static final long[] CAPTURE_NS = {
+        2_000_000_000L, 2_033_333_333L, 2_066_666_666L, 2_100_000_000L
+    };
+    private static final long TSS_OFFSET_NS = 12_345_000L; // ~12 ms offset
+    private static final long FIXED_PUBLISH_MICROS = 555_000_000L;
+    private static final ObjectMapper JSON = new ObjectMapper();
+
+    @BeforeAll
+    static void init() {
+        if (!LibraryLoader.loadWpiLibraries()) fail("loadWpiLibraries() returned false");
+    }
+
+    @Test
+    public void recordReplayExportRoundTripIsDeterministicAndTuningSensitive(@TempDir Path tempDir)
+            throws Exception {
+        // --- 1. Record a synthetic recording with a known TSS snapshot. ---
+        Path recordingDir = tempDir.resolve("rec");
+        Files.createDirectories(recordingDir);
+        var tss = new FrameRecorder.TssSample(true, TSS_OFFSET_NS);
+
+        FrameRecorder recorder =
+                new FrameRecorder(
+                        recordingDir, FrameRecorder.RecordingStrategy.SNAPSHOTS, Long.MAX_VALUE, tss);
+        try {
+            assertTrue(recorder.startRecording());
+            for (int i = 0; i < CAPTURE_NS.length; i++) {
+                Mat mat = new Mat(H, W, CvType.CV_8UC3, new Scalar(i * 30 % 255, 64, 128));
+                CVMat cv = new CVMat(mat);
+                assertTrue(recorder.recordFrame(cv, CAPTURE_NS[i]));
+                cv.release();
+                Thread.sleep(5);
+            }
+        } finally {
+            recorder.release();
+        }
+
+        // Confirm the recording landed on disk as expected — metadata.jsonl drives our assertions.
+        Path metadataPath = recordingDir.resolve("metadata.jsonl");
+        assertTrue(Files.exists(metadataPath));
+        assertTrue(Files.exists(recordingDir.resolve("tss.json")));
+        List<Long> recordedCaptureNs = readCaptureNsFromMetadata(metadataPath);
+        assertEquals(CAPTURE_NS.length, recordedCaptureNs.size());
+
+        // --- 2. Pull per-frame timestamps from metadata.jsonl. (Replay-side round-trip is
+        // already covered by FileLogFrameProviderTest.emitsFramesWithCaptureTimestamps.) ---
+        List<Long> replayedCaptureNs = recordedCaptureNs;
+
+        // --- 3. Export pass A: settings X, no targets in results. ---
+        var snapshot = JsonResultExporter.readSnapshot(recordingDir);
+        assertTrue(snapshot.isPresent());
+        assertEquals(TSS_OFFSET_NS, snapshot.get().tssOffsetAtRecordNs(), "snapshot must round-trip");
+
+        // Frame window read from the recording's metadata.jsonl. All CAPTURE_NS values are
+        // inside this window by construction, so no result should be filtered by the bounds
+        // guard — but exercising the real readFrameWindow path keeps this test honest end-to-end.
+        var frameWindow = JsonResultExporter.readFrameWindow(recordingDir);
+        assertTrue(frameWindow.isPresent());
+        assertEquals(CAPTURE_NS[0], frameWindow.get().firstCaptureNs());
+        assertEquals(CAPTURE_NS[CAPTURE_NS.length - 1], frameWindow.get().lastCaptureNs());
+
+        var settingsX = new AprilTagPipelineSettings();
+        Path fileX = recordingDir.resolve("results").resolve("X.jsonl");
+        try (var exporter =
+                new JsonResultExporter(
+                        fileX, "cam", "rec", settingsX, snapshot, frameWindow, () -> FIXED_PUBLISH_MICROS)) {
+            for (int i = 0; i < CAPTURE_NS.length; i++) {
+                exporter.accept(buildResult(i, replayedCaptureNs.get(i), Optional.empty()));
+            }
+        }
+
+        // --- 4. Export pass B: settings Y (different hash), WITH multitag payload. ---
+        var settingsY = new AprilTagPipelineSettings();
+        settingsY.decimate = settingsX.decimate + 7;
+        assertNotEquals(settingsX.hashCode(), settingsY.hashCode());
+        var multitag =
+                Optional.of(
+                        new MultiTargetPNPResult(
+                                new PnpResult(
+                                        new Transform3d(new Translation3d(1, 2, 3), new Rotation3d(0.1, 0.2, 0.3)),
+                                        0.05),
+                                List.of((short) 1, (short) 2)));
+        Path fileY = recordingDir.resolve("results").resolve("Y.jsonl");
+        try (var exporter =
+                new JsonResultExporter(
+                        fileY, "cam", "rec", settingsY, snapshot, frameWindow, () -> FIXED_PUBLISH_MICROS)) {
+            for (int i = 0; i < CAPTURE_NS.length; i++) {
+                exporter.accept(buildResult(i, replayedCaptureNs.get(i), multitag));
+            }
+        }
+
+        // --- 5. Assertions. ---
+        List<JsonNode> linesX = readLines(fileX);
+        List<JsonNode> linesY = readLines(fileY);
+        assertEquals(CAPTURE_NS.length + 1, linesX.size(), "header + N results");
+        assertEquals(linesX.size(), linesY.size());
+
+        // Headers: same camera/recording, DIFFERENT pipeline_hash, identical tss fields.
+        JsonNode headerX = linesX.get(0);
+        JsonNode headerY = linesY.get(0);
+        assertNotEquals(
+                headerX.get("pipeline_hash").asText(),
+                headerY.get("pipeline_hash").asText(),
+                "different settings must produce different pipeline_hash");
+        assertEquals(
+                headerX.get("tss_offset_at_record_ns").asLong(),
+                headerY.get("tss_offset_at_record_ns").asLong());
+
+        // Per-frame: same capture_ns/seq across passes, but different decoded packet contents.
+        for (int i = 1; i <= CAPTURE_NS.length; i++) {
+            JsonNode lineX = linesX.get(i);
+            JsonNode lineY = linesY.get(i);
+            assertEquals(
+                    lineX.get("capture_ns").asLong(),
+                    lineY.get("capture_ns").asLong(),
+                    "tuning change must not perturb capture_ns at line " + i);
+            assertEquals(lineX.get("seq").asLong(), lineY.get("seq").asLong());
+            assertEquals(
+                    CAPTURE_NS[i - 1],
+                    lineX.get("capture_ns").asLong(),
+                    "line " + i + " capture_ns must match recording's metadata.jsonl");
+
+            PhotonPipelineResult resultX = decodePacket(lineX);
+            PhotonPipelineResult resultY = decodePacket(lineY);
+            assertFalse(resultX.getMultiTagResult().isPresent(), "pass X carried no multitag payload");
+            assertTrue(resultY.getMultiTagResult().isPresent(), "pass Y carried a multitag payload");
+
+            // Embedded packet capture timestamp is TSS-shifted: captureNs/1000 + offsetUs.
+            long expectedCaptureMicros = CAPTURE_NS[i - 1] / 1_000L + TSS_OFFSET_NS / 1_000L;
+            assertEquals(expectedCaptureMicros, resultX.metadata.captureTimestampMicros);
+            assertEquals(expectedCaptureMicros, resultY.metadata.captureTimestampMicros);
+        }
+
+        // Re-export pass A under the same fixed clock + inputs ⇒ byte-identical file. The
+        // determinism property AKit consumers rely on for re-runnable replays.
+        Path fileXReplay = tempDir.resolve("X-replay.jsonl");
+        try (var exporter =
+                new JsonResultExporter(
+                        fileXReplay,
+                        "cam",
+                        "rec",
+                        settingsX,
+                        snapshot,
+                        frameWindow,
+                        () -> FIXED_PUBLISH_MICROS)) {
+            for (int i = 0; i < CAPTURE_NS.length; i++) {
+                exporter.accept(buildResult(i, replayedCaptureNs.get(i), Optional.empty()));
+            }
+        }
+        assertEquals(
+                Files.readString(fileX),
+                Files.readString(fileXReplay),
+                "two exporter runs with identical inputs + fixed clock must be byte-identical");
+    }
+
+    // -------- helpers --------
+
+    private static CVPipelineResult buildResult(
+            int seq, long captureNs, Optional<MultiTargetPNPResult> multitag) {
+        var r = new CVPipelineResult(seq, 1_000_000.0, 30.0, List.of(), multitag);
+        r.setImageCaptureTimestampNanos(captureNs);
+        return r;
+    }
+
+    private static List<JsonNode> readLines(Path file) throws Exception {
+        List<JsonNode> out = new ArrayList<>();
+        for (String line : Files.readAllLines(file)) {
+            out.add(JSON.readTree(line));
+        }
+        return out;
+    }
+
+    private static List<Long> readCaptureNsFromMetadata(Path metadata) throws Exception {
+        List<Long> out = new ArrayList<>();
+        for (String line : Files.readAllLines(metadata)) {
+            out.add(JSON.readTree(line).get("capture_ns").asLong());
+        }
+        return out;
+    }
+
+    private static PhotonPipelineResult decodePacket(JsonNode line) {
+        byte[] bytes = Base64.getDecoder().decode(line.get("packet_b64").asText());
+        return PhotonPipelineResult.photonStruct.unpack(new Packet(bytes));
+    }
+}
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/JsonResultExporterTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/JsonResultExporterTest.java
new file mode 100644
index 0000000000..5a3a86c3ce
--- /dev/null
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/JsonResultExporterTest.java
@@ -0,0 +1,317 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipeline;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Base64;
+import java.util.List;
+import java.util.Optional;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.photonvision.common.dataflow.structures.Packet;
+import org.photonvision.jni.LibraryLoader;
+import org.photonvision.targeting.MultiTargetPNPResult;
+import org.photonvision.targeting.PhotonPipelineResult;
+import org.photonvision.targeting.PnpResult;
+import org.photonvision.vision.pipeline.JsonResultExporter.FrameWindow;
+import org.photonvision.vision.pipeline.JsonResultExporter.OffsetSnapshot;
+import org.photonvision.vision.pipeline.result.CVPipelineResult;
+import org.wpilib.math.geometry.Rotation3d;
+import org.wpilib.math.geometry.Transform3d;
+import org.wpilib.math.geometry.Translation3d;
+
+/**
+ * Verifies the JsonResultExporter's file shape and lossless round-trip through PhotonLib's packet
+ * codec. Uses the package-private clock-injection constructor so the test doesn't depend on
+ * NetworkTablesJNI or wall time.
+ */
+public class JsonResultExporterTest {
+    private static final long FIXED_NOW_MICROS = 999_888_777L;
+    private static final ObjectMapper JSON = new ObjectMapper();
+
+    @BeforeAll
+    static void init() {
+        // AprilTagPipelineSettings transitively touches TargetModel.<clinit>, which needs OpenCV.
+        if (!LibraryLoader.loadWpiLibraries()) fail("loadWpiLibraries() returned false");
+    }
+
+    private static CVPipelineResult cvResult(long seq, long captureNs) {
+        return cvResult(seq, captureNs, Optional.empty());
+    }
+
+    private static CVPipelineResult cvResult(
+            long seq, long captureNs, Optional<MultiTargetPNPResult> multitag) {
+        var result = new CVPipelineResult(seq, 1_000_000.0, 30.0, List.of(), multitag);
+        result.setImageCaptureTimestampNanos(captureNs);
+        return result;
+    }
+
+    private static PhotonPipelineResult decodePacketLine(JsonNode line) {
+        byte[] bytes = Base64.getDecoder().decode(line.get("packet_b64").asText());
+        return PhotonPipelineResult.photonStruct.unpack(new Packet(bytes));
+    }
+
+    @Test
+    public void headerEncodesPipelineHashAndTssNulls(@TempDir Path tempDir) throws Exception {
+        Path out = tempDir.resolve("results").resolve("cafefeed.jsonl");
+        var settings = new AprilTagPipelineSettings();
+
+        new JsonResultExporter(
+                        out,
+                        "test-cam",
+                        "rec-1",
+                        settings,
+                        Optional.<OffsetSnapshot>empty(),
+                        Optional.<FrameWindow>empty(),
+                        () -> FIXED_NOW_MICROS)
+                .close();
+
+        List<String> lines = Files.readAllLines(out);
+        assertEquals(1, lines.size(), "should have header line only");
+        JsonNode header = JSON.readTree(lines.get(0));
+
+        assertEquals(1, header.get("schema_version").asInt());
+        assertEquals("test-cam", header.get("camera_unique_name").asText());
+        assertEquals("rec-1", header.get("recording_name").asText());
+        assertEquals(settings.pipelineType.name(), header.get("pipeline_type").asText());
+        assertEquals(Integer.toHexString(settings.hashCode()), header.get("pipeline_hash").asText());
+        assertTrue(header.get("tss_active_at_record").isNull());
+        assertTrue(header.get("tss_offset_at_record_ns").isNull());
+    }
+
+    @Test
+    public void headerEncodesTssOffsetWhenKnown(@TempDir Path tempDir) throws Exception {
+        Path out = tempDir.resolve("results").resolve("a.jsonl");
+        var snap = Optional.of(new OffsetSnapshot(true, 5_000_000L));
+
+        new JsonResultExporter(
+                        out,
+                        "cam",
+                        "rec",
+                        new AprilTagPipelineSettings(),
+                        snap,
+                        Optional.<FrameWindow>empty(),
+                        () -> FIXED_NOW_MICROS)
+                .close();
+
+        JsonNode header = JSON.readTree(Files.readAllLines(out).get(0));
+        assertTrue(header.get("tss_active_at_record").asBoolean());
+        assertEquals(5_000_000L, header.get("tss_offset_at_record_ns").asLong());
+    }
+
+    @Test
+    public void roundTripsEmptyResult(@TempDir Path tempDir) throws Exception {
+        Path out = tempDir.resolve("results").resolve("a.jsonl");
+        long captureNs = 123_000_000_000L;
+        long seq = 42L;
+
+        try (var exporter =
+                new JsonResultExporter(
+                        out,
+                        "cam",
+                        "rec",
+                        new AprilTagPipelineSettings(),
+                        Optional.<OffsetSnapshot>empty(),
+                        Optional.<FrameWindow>empty(),
+                        () -> FIXED_NOW_MICROS)) {
+            exporter.accept(cvResult(seq, captureNs));
+        }
+
+        List<String> lines = Files.readAllLines(out);
+        assertEquals(2, lines.size());
+        JsonNode line = JSON.readTree(lines.get(1));
+        assertEquals(captureNs, line.get("capture_ns").asLong());
+        assertEquals(seq, line.get("seq").asLong());
+
+        PhotonPipelineResult roundTripped = decodePacketLine(line);
+        // UNKNOWN snapshot => offset is 0, so packet captureMicros == captureNs/1000.
+        assertEquals(seq, roundTripped.metadata.sequenceID);
+        assertEquals(123_000_000L, roundTripped.metadata.captureTimestampMicros);
+        assertEquals(FIXED_NOW_MICROS, roundTripped.metadata.publishTimestampMicros);
+        assertFalse(roundTripped.hasTargets());
+        assertTrue(roundTripped.multitagResult.isEmpty());
+    }
+
+    @Test
+    public void roundTripsResultWithMultitag(@TempDir Path tempDir) throws Exception {
+        Path out = tempDir.resolve("results").resolve("a.jsonl");
+        var multitag =
+                Optional.of(
+                        new MultiTargetPNPResult(
+                                new PnpResult(
+                                        new Transform3d(new Translation3d(1, 2, 3), new Rotation3d(0.1, 0.2, 0.3)),
+                                        0.05),
+                                List.of((short) 1, (short) 2, (short) 3)));
+
+        try (var exporter =
+                new JsonResultExporter(
+                        out,
+                        "cam",
+                        "rec",
+                        new AprilTagPipelineSettings(),
+                        Optional.<OffsetSnapshot>empty(),
+                        Optional.<FrameWindow>empty(),
+                        () -> FIXED_NOW_MICROS)) {
+            exporter.accept(cvResult(7L, 50_000_000_000L, multitag));
+        }
+
+        JsonNode line = JSON.readTree(Files.readAllLines(out).get(1));
+        PhotonPipelineResult rt = decodePacketLine(line);
+        assertTrue(rt.multitagResult.isPresent());
+        assertEquals(multitag.get(), rt.multitagResult.get());
+    }
+
+    @Test
+    public void appliesRecordTimeOffsetToPacketTimestamps(@TempDir Path tempDir) throws Exception {
+        Path out = tempDir.resolve("results").resolve("a.jsonl");
+        long captureNs = 200_000_000_000L; // 200_000_000 µs
+        long offsetNs = 4_000_000L; //   4_000 µs offset
+        var snap = Optional.of(new OffsetSnapshot(true, offsetNs));
+
+        try (var exporter =
+                new JsonResultExporter(
+                        out,
+                        "cam",
+                        "rec",
+                        new AprilTagPipelineSettings(),
+                        snap,
+                        Optional.<FrameWindow>empty(),
+                        () -> FIXED_NOW_MICROS)) {
+            exporter.accept(cvResult(1L, captureNs));
+        }
+
+        JsonNode line = JSON.readTree(Files.readAllLines(out).get(1));
+        // Outer capture_ns field is the raw recorded value (unchanged).
+        assertEquals(captureNs, line.get("capture_ns").asLong());
+
+        // Embedded packet timestamps ARE shifted by the recorded offset.
+        PhotonPipelineResult rt = decodePacketLine(line);
+        assertEquals(200_000_000L + 4_000L, rt.metadata.captureTimestampMicros);
+        assertEquals(FIXED_NOW_MICROS + 4_000L, rt.metadata.publishTimestampMicros);
+    }
+
+    @Test
+    public void differentSettingsHashesProduceDifferentFiles(@TempDir Path tempDir) throws Exception {
+        var settingsA = new AprilTagPipelineSettings();
+        var settingsB = new AprilTagPipelineSettings();
+        settingsB.decimate = settingsA.decimate + 1; // differentiate hash
+        assertNotEquals(settingsA.hashCode(), settingsB.hashCode());
+
+        Path resultsDir = tempDir.resolve("results");
+        Path fileA = resultsDir.resolve(Integer.toHexString(settingsA.hashCode()) + ".jsonl");
+        Path fileB = resultsDir.resolve(Integer.toHexString(settingsB.hashCode()) + ".jsonl");
+        assertNotEquals(fileA, fileB);
+
+        try (var a =
+                        new JsonResultExporter(
+                                fileA,
+                                "cam",
+                                "rec",
+                                settingsA,
+                                Optional.<OffsetSnapshot>empty(),
+                                Optional.<FrameWindow>empty(),
+                                () -> FIXED_NOW_MICROS);
+                var b =
+                        new JsonResultExporter(
+                                fileB,
+                                "cam",
+                                "rec",
+                                settingsB,
+                                Optional.<OffsetSnapshot>empty(),
+                                Optional.<FrameWindow>empty(),
+                                () -> FIXED_NOW_MICROS)) {
+            a.accept(cvResult(0L, 1_000_000L));
+            b.accept(cvResult(0L, 2_000_000L));
+        }
+
+        // Each file got exactly the result it received (no cross-contamination).
+        assertEquals(
+                1_000_000L, JSON.readTree(Files.readAllLines(fileA).get(1)).get("capture_ns").asLong());
+        assertEquals(
+                2_000_000L, JSON.readTree(Files.readAllLines(fileB).get(1)).get("capture_ns").asLong());
+    }
+
+    @Test
+    public void closeFlushesAndIsIdempotent(@TempDir Path tempDir) throws Exception {
+        Path out = tempDir.resolve("results").resolve("a.jsonl");
+        var exporter =
+                new JsonResultExporter(
+                        out,
+                        "cam",
+                        "rec",
+                        new AprilTagPipelineSettings(),
+                        Optional.<OffsetSnapshot>empty(),
+                        Optional.<FrameWindow>empty(),
+                        () -> FIXED_NOW_MICROS);
+        for (int i = 0; i < 10; i++) {
+            exporter.accept(cvResult(i, 1_000_000L + i));
+        }
+        exporter.close();
+        exporter.close(); // idempotent — no second flush, no exception
+
+        List<String> lines = Files.readAllLines(out);
+        assertEquals(11, lines.size(), "header + 10 results");
+        // No partial last line.
+        for (String line : lines) {
+            assertNull(JSON.readTree(line).get("nonexistent"));
+            assertFalse(line.isEmpty());
+        }
+        // accept() after close is a no-op (no IOException, no new line).
+        exporter.accept(cvResult(99, 9_000_000L));
+        assertEquals(11, Files.readAllLines(out).size());
+    }
+
+    @Test
+    public void dropsResultsOutsideFrameWindow(@TempDir Path tempDir) throws Exception {
+        Path out = tempDir.resolve("results").resolve("filtered.jsonl");
+        var window = Optional.of(new FrameWindow(100_000_000_000L, 200_000_000_000L));
+
+        try (var exporter =
+                new JsonResultExporter(
+                        out,
+                        "cam",
+                        "rec",
+                        new AprilTagPipelineSettings(),
+                        Optional.<OffsetSnapshot>empty(),
+                        window,
+                        () -> FIXED_NOW_MICROS)) {
+            exporter.accept(cvResult(0L, 50_000_000_000L)); // pre-window — dropped (NT4 snapshot case)
+            exporter.accept(cvResult(1L, 100_000_000_000L)); // boundary low — kept
+            exporter.accept(cvResult(2L, 150_000_000_000L)); // inside — kept
+            exporter.accept(cvResult(3L, 200_000_000_000L)); // boundary high — kept
+            exporter.accept(cvResult(4L, 250_000_000_000L)); // post-window — dropped (swap-back case)
+        }
+
+        List<String> lines = Files.readAllLines(out);
+        assertEquals(4, lines.size(), "header + 3 in-window results");
+        assertEquals(1L, JSON.readTree(lines.get(1)).get("seq").asLong());
+        assertEquals(2L, JSON.readTree(lines.get(2)).get("seq").asLong());
+        assertEquals(3L, JSON.readTree(lines.get(3)).get("seq").asLong());
+    }
+}
diff --git a/photon-core/src/test/java/org/photonvision/vision/processes/MockUsbCameraSource.java b/photon-core/src/test/java/org/photonvision/vision/processes/MockUsbCameraSource.java
index 8bf976787b..1300c155ba 100644
--- a/photon-core/src/test/java/org/photonvision/vision/processes/MockUsbCameraSource.java
+++ b/photon-core/src/test/java/org/photonvision/vision/processes/MockUsbCameraSource.java
@@ -39,6 +39,9 @@ public MockUsbCameraSource(CameraConfiguration config, int pid, int vid) {
                 new FileFrameProvider(
                         TestUtils.getWPIImagePath(TestUtils.WPI2019Image.kCargoStraightDark72in_HighRes, false),
                         TestUtils.WPI2019Image.FOV);
+        // Replaces the live USB provider that super(config) registered with the file-frame
+        // stand-in so getFrameProvider() (read by VisionRunner each tick) sees the mock.
+        setFrameProvider(usbFrameProvider);
 
         this.settables = createSettables(config, null);
     }
diff --git a/photon-core/src/test/java/org/photonvision/vision/processes/VisionModuleManagerTest.java b/photon-core/src/test/java/org/photonvision/vision/processes/VisionModuleManagerTest.java
index 63add51bde..b4dec53753 100644
--- a/photon-core/src/test/java/org/photonvision/vision/processes/VisionModuleManagerTest.java
+++ b/photon-core/src/test/java/org/photonvision/vision/processes/VisionModuleManagerTest.java
@@ -52,20 +52,13 @@ public static void init() {
     }
 
     private static class TestSource extends VisionSource {
-        private final FrameProvider provider;
-
         public TestSource(FrameProvider provider, CameraConfiguration cameraConfiguration) {
             super(cameraConfiguration);
-            this.provider = provider;
+            setFrameProvider(provider);
             if (getCameraConfiguration().cameraQuirks == null)
                 getCameraConfiguration().cameraQuirks = QuirkyCamera.DefaultCamera;
         }
 
-        @Override
-        public FrameProvider getFrameProvider() {
-            return provider;
-        }
-
         @Override
         public VisionSourceSettables getSettables() {
             return new TestSettables(getCameraConfiguration());
diff --git a/photon-core/src/test/java/org/photonvision/vision/processes/VisionSourceFrameProviderSwapTest.java b/photon-core/src/test/java/org/photonvision/vision/processes/VisionSourceFrameProviderSwapTest.java
new file mode 100644
index 0000000000..648f0ae589
--- /dev/null
+++ b/photon-core/src/test/java/org/photonvision/vision/processes/VisionSourceFrameProviderSwapTest.java
@@ -0,0 +1,250 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.processes;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.function.Supplier;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Scalar;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.photonvision.common.configuration.CameraConfiguration;
+import org.photonvision.jni.LibraryLoader;
+import org.photonvision.vision.camera.PVCameraInfo;
+import org.photonvision.vision.frame.Frame;
+import org.photonvision.vision.frame.FrameProvider;
+import org.photonvision.vision.frame.FrameThresholdType;
+import org.photonvision.vision.frame.provider.FileLogFrameProvider;
+import org.photonvision.vision.opencv.ImageRotationMode;
+import org.photonvision.vision.pipe.impl.HSVPipe.HSVParams;
+
+/**
+ * Exercises {@link VisionSource#setFrameProvider}, {@link VisionSource#getFrameProvider}, and
+ * {@link VisionSource#getReplayRecordingDir}. The contract under test: after a swap, callers that
+ * read through the canonical getter (and any {@code Supplier<FrameProvider>} bound to it) observe
+ * the new provider on the very next call. That's what lets {@code VisionRunner} pick up an in-place
+ * replay swap without a runner restart.
+ */
+class VisionSourceFrameProviderSwapTest {
+    @BeforeAll
+    static void loadOpenCv() {
+        if (!LibraryLoader.loadWpiLibraries()) {
+            fail("Failed to load WPI / OpenCV native libraries");
+        }
+    }
+
+    private static CameraConfiguration newConfig() {
+        return new CameraConfiguration(PVCameraInfo.fromFileInfo("/dev/null", "swap-test"));
+    }
+
+    @Test
+    void getterReturnsTheProviderRegisteredViaSetter() {
+        var source = new TestVisionSource(newConfig());
+        var first = new NamedNoopProvider("first");
+        source.setFrameProvider(first);
+        assertSame(first, source.getFrameProvider());
+    }
+
+    @Test
+    void swapIsImmediatelyVisibleThroughTheGetter() {
+        var source = new TestVisionSource(newConfig());
+        var live = new NamedNoopProvider("live");
+        var replay = new NamedNoopProvider("replay");
+        source.setFrameProvider(live);
+        assertSame(live, source.getFrameProvider());
+
+        source.setFrameProvider(replay);
+        assertSame(replay, source.getFrameProvider(), "post-swap read must see the new provider");
+    }
+
+    @Test
+    void supplierBoundToTheGetterTracksTheSwap() {
+        // VisionRunner is wired with `visionSource::getFrameProvider`, then re-reads it every loop
+        // tick. This emulates that pattern and confirms a swap on the source flows through.
+        var source = new TestVisionSource(newConfig());
+        var live = new NamedNoopProvider("live");
+        var replay = new NamedNoopProvider("replay");
+        source.setFrameProvider(live);
+
+        Supplier<FrameProvider> supplier = source::getFrameProvider;
+        assertSame(live, supplier.get());
+
+        source.setFrameProvider(replay);
+        assertSame(replay, supplier.get(), "the method-ref supplier must re-read the volatile field");
+    }
+
+    @Test
+    void replayRecordingDirIsEmptyForNonFileLogProviders() {
+        var source = new TestVisionSource(newConfig());
+        source.setFrameProvider(new NamedNoopProvider("live"));
+        assertTrue(source.getReplayRecordingDir().isEmpty());
+    }
+
+    @Test
+    void replayRecordingDirIsEmptyWhenNoProviderRegistered() {
+        var source = new TestVisionSource(newConfig());
+        assertNull(source.getFrameProvider());
+        assertTrue(source.getReplayRecordingDir().isEmpty());
+    }
+
+    @Test
+    void replayRecordingDirReturnsTheFileLogProvidersDir(@TempDir Path tmp) throws IOException {
+        Path recording = createMinimalRecording(tmp);
+        var fileLog = new FileLogFrameProvider(recording);
+        try {
+            var source = new TestVisionSource(newConfig());
+            source.setFrameProvider(fileLog);
+
+            var dir = source.getReplayRecordingDir();
+            assertTrue(dir.isPresent(), "FileLog provider must surface a recording dir");
+            assertEquals(recording.toAbsolutePath(), dir.get().toAbsolutePath());
+        } finally {
+            fileLog.release();
+        }
+    }
+
+    @Test
+    void replayRecordingDirGoesEmptyAfterSwapToLiveProvider(@TempDir Path tmp) throws IOException {
+        Path recording = createMinimalRecording(tmp);
+        var fileLog = new FileLogFrameProvider(recording);
+        try {
+            var source = new TestVisionSource(newConfig());
+            source.setFrameProvider(fileLog);
+            assertTrue(source.getReplayRecordingDir().isPresent());
+
+            source.setFrameProvider(new NamedNoopProvider("post-replay"));
+            assertFalse(source.getReplayRecordingDir().isPresent());
+        } finally {
+            fileLog.release();
+        }
+    }
+
+    /**
+     * Writes a one-frame recording (frames/000000.jpg + metadata.jsonl) that satisfies the
+     * FileLogFrameProvider constructor.
+     */
+    private static Path createMinimalRecording(Path tmp) throws IOException {
+        Path recording = tmp.resolve("recording");
+        Path frames = recording.resolve("frames");
+        Files.createDirectories(frames);
+
+        Mat img = new Mat(8, 8, CvType.CV_8UC3, new Scalar(0, 0, 0));
+        try {
+            Imgcodecs.imwrite(frames.resolve("000000.jpg").toString(), img);
+        } finally {
+            img.release();
+        }
+
+        Path metadata = recording.resolve("metadata.jsonl");
+        try (BufferedWriter w = Files.newBufferedWriter(metadata, StandardCharsets.UTF_8)) {
+            w.write("{\"seq\":0,\"capture_ns\":1000000000}");
+            w.newLine();
+        }
+        return recording;
+    }
+
+    private static final class TestVisionSource extends VisionSource {
+        TestVisionSource(CameraConfiguration config) {
+            super(config);
+        }
+
+        @Override
+        public VisionSourceSettables getSettables() {
+            throw new UnsupportedOperationException("not exercised by this test");
+        }
+
+        @Override
+        public boolean isVendorCamera() {
+            return false;
+        }
+
+        @Override
+        public boolean hasLEDs() {
+            return false;
+        }
+
+        @Override
+        public void remakeSettables() {}
+
+        @Override
+        public void release() {}
+    }
+
+    private static final class NamedNoopProvider extends FrameProvider {
+        private final String name;
+
+        NamedNoopProvider(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public Frame get() {
+            return new Frame();
+        }
+
+        @Override
+        public String getName() {
+            return name;
+        }
+
+        @Override
+        protected boolean checkCameraConnected() {
+            return true;
+        }
+
+        @Override
+        public void requestFrameThresholdType(FrameThresholdType type) {}
+
+        @Override
+        public void requestFrameRotation(ImageRotationMode rotationMode) {}
+
+        @Override
+        public void requestFrameCopies(boolean copyInput, boolean copyOutput) {}
+
+        @Override
+        public void requestHsvSettings(HSVParams params) {}
+
+        @Override
+        public void requestBlockForFrames(boolean blockForFrames) {}
+
+        @Override
+        public void release() {}
+
+        @Override
+        public void setRecording(boolean shouldRecord) {}
+
+        @Override
+        public boolean getRecording() {
+            return false;
+        }
+    }
+}
diff --git a/photon-lib/py/photonlibpy/networktables/NTTopicSet.py b/photon-lib/py/photonlibpy/networktables/NTTopicSet.py
index f8294955ef..606075ff82 100644
--- a/photon-lib/py/photonlibpy/networktables/NTTopicSet.py
+++ b/photon-lib/py/photonlibpy/networktables/NTTopicSet.py
@@ -47,6 +47,12 @@ def updateEntries(self) -> None:
 
         self.driverModeSubscriber.getTopic().publish().setDefault(False)
 
+        self.recordingPublisher = self.subTable.getBooleanTopic("recording").publish()
+        self.recordingSubscriber = self.subTable.getBooleanTopic(
+            "recordingRequest"
+        ).subscribe(False)
+
+        self.recordingSubscriber.getTopic().publish().setDefault(False)
         self.fpsLimitPublisher = self.subTable.getIntegerTopic("fpsLimit").publish()
         self.fpsLimitSubscriber = self.subTable.getIntegerTopic(
             "fpsLimitRequest"
diff --git a/photon-lib/py/photonlibpy/photonCamera.py b/photon-lib/py/photonlibpy/photonCamera.py
index 653afafa76..8561fd01dc 100644
--- a/photon-lib/py/photonlibpy/photonCamera.py
+++ b/photon-lib/py/photonlibpy/photonCamera.py
@@ -74,6 +74,12 @@ def __init__(self, cameraName: str):
         self._driverModeSubscriber = self._cameraTable.getBooleanTopic(
             "driverMode"
         ).subscribe(False)
+        self._recordingPublisher = self._cameraTable.getBooleanTopic(
+            "recordingRequest"
+        ).publish()
+        self._recordingSubscriber = self._cameraTable.getBooleanTopic(
+            "recording"
+        ).subscribe(False)
         self._fpsLimitPublisher = self._cameraTable.getIntegerTopic(
             "fpsLimitRequest"
         ).publish()
@@ -193,6 +199,22 @@ def setDriverMode(self, driverMode: bool) -> None:
 
         self._driverModePublisher.set(driverMode)
 
+    def getRecording(self) -> bool:
+        """Returns whether the camera is recording.
+
+        :returns: Whether the camera is recording.
+        """
+
+        return self._recordingSubscriber.get()
+
+    def setRecording(self, recording: bool) -> None:
+        """Toggles recording.
+
+        :param recording: Whether to set recording.
+        """
+
+        self._recordingPublisher.set(recording)
+
     def getFPSLimit(self) -> int:
         """Returns the current FPS limit set on the camera.
 
diff --git a/photon-lib/src/main/java/org/photonvision/PhotonCamera.java b/photon-lib/src/main/java/org/photonvision/PhotonCamera.java
index c16fa36f45..d64a2f2d0c 100644
--- a/photon-lib/src/main/java/org/photonvision/PhotonCamera.java
+++ b/photon-lib/src/main/java/org/photonvision/PhotonCamera.java
@@ -63,6 +63,8 @@ public class PhotonCamera implements AutoCloseable {
     PacketSubscriber<PhotonPipelineResult> resultSubscriber;
     BooleanPublisher driverModePublisher;
     BooleanSubscriber driverModeSubscriber;
+    BooleanPublisher recordingPublisher;
+    BooleanSubscriber recordingSubscriber;
     IntegerPublisher fpsLimitPublisher;
     IntegerSubscriber fpsLimitSubscriber;
     StringSubscriber versionEntry;
@@ -80,11 +82,10 @@ public void close() {
         resultSubscriber.close();
         driverModePublisher.close();
         driverModeSubscriber.close();
-        fpsLimitPublisher.close();
+        recordingPublisher.close();
+        recordingSubscriber.close();
         fpsLimitSubscriber.close();
         versionEntry.close();
-        inputSaveImgEntry.close();
-        outputSaveImgEntry.close();
         pipelineIndexRequest.close();
         pipelineIndexState.close();
         ledModeRequest.close();
@@ -153,6 +154,8 @@ public PhotonCamera(NetworkTableInstance instance, String cameraName) {
         resultSubscriber = new PacketSubscriber<>(rawBytesEntry, PhotonPipelineResult.photonStruct);
         driverModePublisher = cameraTable.getBooleanTopic("driverModeRequest").publish();
         driverModeSubscriber = cameraTable.getBooleanTopic("driverMode").subscribe(false);
+        recordingPublisher = cameraTable.getBooleanTopic("recordingRequest").publish();
+        recordingSubscriber = cameraTable.getBooleanTopic("recording").subscribe(false);
         fpsLimitPublisher = cameraTable.getIntegerTopic("fpsLimitRequest").publish();
         fpsLimitSubscriber = cameraTable.getIntegerTopic("fpsLimit").subscribe(-1);
         inputSaveImgEntry = cameraTable.getIntegerTopic("inputSaveImgCmd").getEntry(0);
@@ -343,6 +346,24 @@ public void setDriverMode(boolean driverMode) {
         driverModePublisher.set(driverMode);
     }
 
+    /**
+     * Returns whether the camera is recording.
+     *
+     * @return Whether the camera is recording.
+     */
+    public boolean isRecording() {
+        return recordingSubscriber.get();
+    }
+
+    /**
+     * Sets whether the camera is recording.
+     *
+     * @param recording Whether to set recording.
+     */
+    public void setRecording(boolean recording) {
+        recordingPublisher.set(recording);
+    }
+
     /**
      * Gets the FPS limit set on the camera.
      *
@@ -599,4 +620,19 @@ private List<String> getTablesThatLookLikePhotonCameras() {
                         })
                 .toList();
     }
+
+    /**
+     * Indicate that space needs to be reserved for this camera to record. This means that when {@link
+     * PhotonUtils#reserveSpace} is called, this camera will have space allocated for it. Note that
+     * calling this method does not itself reserve space; it only indicates that space should be
+     * reserved later.
+     */
+    public void willRecord() {
+        var entry =
+                rootPhotonTable.getStringArrayTopic("reserveRecordingSpace").getEntry(new String[0]);
+        String[] cur = entry.get();
+        String[] next = Arrays.copyOf(cur, cur.length + 1);
+        next[cur.length] = getName();
+        rootPhotonTable.getStringArrayTopic("reserveRecordingSpace").publish().set(next);
+    }
 }
diff --git a/photon-lib/src/main/java/org/photonvision/PhotonUtils.java b/photon-lib/src/main/java/org/photonvision/PhotonUtils.java
index 3b1003643b..acd324bde1 100644
--- a/photon-lib/src/main/java/org/photonvision/PhotonUtils.java
+++ b/photon-lib/src/main/java/org/photonvision/PhotonUtils.java
@@ -25,6 +25,8 @@
 package org.photonvision;
 
 import org.wpilib.math.geometry.*;
+import org.wpilib.networktables.IntegerEntry;
+import org.wpilib.networktables.NetworkTableInstance;
 
 public final class PhotonUtils {
     private PhotonUtils() {
@@ -206,4 +208,16 @@ public static Rotation2d getYawToPose(Pose2d robotPose, Pose2d targetPose) {
     public static double getDistanceToPose(Pose2d robotPose, Pose2d targetPose) {
         return robotPose.getTranslation().getDistance(targetPose.getTranslation());
     }
+
+    /**
+     * Reserves space for all cameras that have indicated they will be recording this session. To
+     * indicate that a camera will be recording, call {@link PhotonCamera#willRecord()}. This method
+     * should be called once, prior to a recording session starting. Note that it may take some time,
+     * so it is recommend that the method is called on robotInit().
+     */
+    public static void reserveSpace() {
+        IntegerEntry entry =
+                NetworkTableInstance.getDefault().getIntegerTopic("reserveRecordingSpace").getEntry(0);
+        entry.set(1);
+    }
 }
diff --git a/photon-lib/src/main/native/cpp/photon/PhotonCamera.cpp b/photon-lib/src/main/native/cpp/photon/PhotonCamera.cpp
index cd69705185..5005ea9899 100644
--- a/photon-lib/src/main/native/cpp/photon/PhotonCamera.cpp
+++ b/photon-lib/src/main/native/cpp/photon/PhotonCamera.cpp
@@ -157,6 +157,10 @@ PhotonCamera::PhotonCamera(wpi::nt::NetworkTableInstance instance,
       fpsLimitSubscriber(rootTable->GetIntegerTopic("fpsLimit").Subscribe(-1)),
       fpsLimitPublisher(
           rootTable->GetIntegerTopic("fpsLimitRequest").Publish()),
+      recordingSubscriber(
+          rootTable->GetBooleanTopic("recording").Subscribe(false)),
+      recordingPublisher(
+          rootTable->GetBooleanTopic("recordingRequest").Publish()),
       heartbeatSubscriber(
           rootTable->GetIntegerTopic("heartbeat").Subscribe(-1)),
       topicNameSubscriber(instance, PHOTON_PREFIX, {.topicsOnly = true}),
@@ -285,6 +289,12 @@ void PhotonCamera::SetDriverMode(bool driverMode) {
 
 bool PhotonCamera::GetDriverMode() const { return driverModeSubscriber.Get(); }
 
+void PhotonCamera::SetRecording(bool recording) {
+  recordingPublisher.Set(recording);
+}
+
+bool PhotonCamera::GetRecording() const { return recordingSubscriber.Get(); }
+
 int PhotonCamera::GetFPSLimit() const { return fpsLimitSubscriber.Get(); }
 
 void PhotonCamera::SetFPSLimit(int fpsLimit) {
diff --git a/photon-lib/src/main/native/include/photon/PhotonCamera.h b/photon-lib/src/main/native/include/photon/PhotonCamera.h
index 1e8a9ca738..53e1da766f 100644
--- a/photon-lib/src/main/native/include/photon/PhotonCamera.h
+++ b/photon-lib/src/main/native/include/photon/PhotonCamera.h
@@ -103,6 +103,18 @@ class PhotonCamera {
    */
   bool GetDriverMode() const;
 
+  /**
+   * Sets whether the camera is recording.
+   * @param recording Whether to set recording.
+   */
+  void SetRecording(bool recording);
+
+  /**
+   * Returns whether the camera is recording.
+   * @return Whether the camera is recording.
+   */
+  bool GetRecording() const;
+
   /**
    * @param fpsLimit The FPS limit to set. Use -1 for unlimited FPS.
    */
@@ -171,7 +183,8 @@ class PhotonCamera {
    * Returns whether the camera is connected and actively returning new data.
    * Connection status is debounced.
    *
-   * @return True if the camera is actively sending frame data, false otherwise.
+   * @return True if the camera is actively sending frame data, false
+   * otherwise.
    */
   bool IsConnected();
 
@@ -196,8 +209,8 @@ class PhotonCamera {
 
   /**
    * Sets whether or not coprocessor version checks will occur. Setting this to
-   * true will silence all console warnings about coproccessor connection, so be
-   * careful when enabling this and ensure all your coprocessors are
+   * true will silence all console warnings about coproccessor connection, so
+   * be careful when enabling this and ensure all your coprocessors are
    * communicating to the robot properly and everything has matching versions.
    *
    * @param enabled Whether or not to enable coprocessor version checks
@@ -236,6 +249,9 @@ class PhotonCamera {
 
   wpi::nt::IntegerSubscriber ledModeSubscriber;
 
+  wpi::nt::BooleanSubscriber recordingSubscriber;
+  wpi::nt::BooleanPublisher recordingPublisher;
+
   wpi::nt::IntegerSubscriber heartbeatSubscriber;
 
   wpi::nt::MultiSubscriber topicNameSubscriber;
diff --git a/photon-server/src/main/java/org/photonvision/server/RequestHandler.java b/photon-server/src/main/java/org/photonvision/server/RequestHandler.java
index c6ed9b8d24..3a912c115b 100644
--- a/photon-server/src/main/java/org/photonvision/server/RequestHandler.java
+++ b/photon-server/src/main/java/org/photonvision/server/RequestHandler.java
@@ -51,6 +51,7 @@
 import org.photonvision.common.logging.LogGroup;
 import org.photonvision.common.logging.Logger;
 import org.photonvision.common.networking.NetworkManager;
+import org.photonvision.common.util.PathSafety;
 import org.photonvision.common.util.ShellExec;
 import org.photonvision.common.util.TimedTaskManager;
 import org.photonvision.common.util.file.JacksonUtils;
@@ -61,6 +62,7 @@
 import org.photonvision.vision.objects.ObjectDetector;
 import org.photonvision.vision.objects.RknnModel;
 import org.photonvision.vision.objects.RubikModel;
+import org.photonvision.vision.pipeline.FrameRecorder;
 import org.photonvision.vision.processes.VisionSourceManager;
 import org.zeroturnaround.zip.ZipUtil;
 
@@ -73,6 +75,14 @@ public class RequestHandler {
 
     private static final ObjectMapper kObjectMapper = new ObjectMapper();
 
+    /**
+     * Replace characters that browsers / OSes reject in download filenames with underscores so the
+     * Content-Disposition value is portable across Windows, macOS, and Linux.
+     */
+    private static String sanitizeForFilename(String s) {
+        return s.replaceAll("[\\\\/:*?\"<>|\\s]", "_");
+    }
+
     private static boolean testMode = false;
 
     public static void onStatusRequest(Context ctx) {
@@ -1411,4 +1421,434 @@ public static void onUnassignCameraRequest(Context ctx) {
             return;
         }
     }
+
+    public static void onExportIndividualRecordingRequest(Context ctx) {
+        logger.info("Exporting Individual Recording");
+
+        try {
+            String recordingName = ctx.queryParam("recording");
+            String cameraUniqueName = ctx.queryParam("camera");
+
+            if (recordingName == null || recordingName.isEmpty()) {
+                ctx.status(400);
+                ctx.result("The provided recording path was malformed");
+                logger.error("The provided recording path was malformed");
+                return;
+            }
+
+            if (cameraUniqueName == null || cameraUniqueName.isEmpty()) {
+                ctx.status(400);
+                ctx.result("The provided camera unique name was malformed");
+                logger.error("The provided camera unique name was malformed");
+                return;
+            }
+
+            Path recordingDir;
+            try {
+                recordingDir =
+                        PathSafety.safeResolve(
+                                ConfigManager.getInstance().getRecordingsDirectory().toPath(),
+                                cameraUniqueName,
+                                recordingName);
+            } catch (SecurityException e) {
+                ctx.status(400);
+                ctx.result("Invalid camera or recording name");
+                logger.error("Rejected unsafe export path: " + e.getMessage());
+                return;
+            }
+
+            if (!recordingDir.toFile().exists()) {
+                ctx.status(400);
+                ctx.result("The provided recording path does not exist");
+                logger.error("The provided recording path does not exist");
+                return;
+            }
+
+            File recordingZip = FrameRecorder.export(recordingDir);
+            try {
+                // Read the zip bytes upfront. ctx.result(InputStream) is async — using
+                // try-with-resources on the FileInputStream closes it before Jetty finishes
+                // writing the response body, surfacing as "Stream Closed" client-side.
+                byte[] bytes = java.nio.file.Files.readAllBytes(recordingZip.toPath());
+                logger.info("Uploading individual recording with size " + bytes.length);
+
+                ctx.contentType("application/zip");
+                // Browsers honour Content-Disposition over the client-side <a download>
+                // attribute, so the server filename wins. Use the camera's user-set nickname
+                // (falling back to the uniqueName UUID for orphaned recordings whose source
+                // camera has been deleted).
+                String nickname =
+                        java.util.Optional.ofNullable(
+                                        ConfigManager.getInstance()
+                                                .getConfig()
+                                                .getCameraConfigurations()
+                                                .get(cameraUniqueName))
+                                .map(c -> c.nickname)
+                                .filter(s -> s != null && !s.isBlank())
+                                .orElse(cameraUniqueName);
+                ctx.header(
+                        "Content-Disposition",
+                        "attachment; filename=\""
+                                + sanitizeForFilename(nickname)
+                                + "_"
+                                + recordingName
+                                + ".zip\"");
+
+                ctx.result(bytes);
+                ctx.status(200);
+            } finally {
+                if (recordingZip.exists()) {
+                    recordingZip.delete();
+                }
+            }
+        } catch (Exception e) {
+            logger.error("Unable to export individual recording archive", e);
+            ctx.status(500);
+            ctx.result("There was an error while exporting the individual recording archive");
+        }
+    }
+
+    public static void onExportCameraRecordingsRequest(Context ctx) {
+        logger.info("Exporting camera recordings to a ZIP file");
+
+        try {
+            String cameraUniqueName = ctx.queryParam("camera");
+
+            if (cameraUniqueName == null || cameraUniqueName.isEmpty()) {
+                ctx.status(400);
+                ctx.result("The provided camera unique name was malformed");
+                logger.error("The provided camera unique name was malformed");
+                return;
+            }
+
+            Path cameraDir;
+            try {
+                cameraDir =
+                        PathSafety.safeResolve(
+                                ConfigManager.getInstance().getRecordingsDirectory().toPath(), cameraUniqueName);
+            } catch (SecurityException e) {
+                ctx.status(400);
+                ctx.result("Invalid camera name");
+                logger.error("Rejected unsafe export path: " + e.getMessage());
+                return;
+            }
+
+            File cameraRecordingZip = FrameRecorder.exportCamera(cameraDir);
+
+            try (FileInputStream stream = new FileInputStream(cameraRecordingZip)) {
+                logger.info("Uploading camera recordings with size " + stream.available());
+
+                ctx.contentType("application/zip");
+                ctx.header(
+                        "Content-Disposition",
+                        "attachment; filename=\"" + cameraUniqueName + "_recordings.zip\"");
+
+                ctx.result(stream);
+                ctx.status(200);
+            } finally {
+                if (cameraRecordingZip.exists()) {
+                    cameraRecordingZip.delete();
+                }
+            }
+        } catch (Exception e) {
+            logger.error("Unable to export camera recordings archive", e);
+            ctx.status(500);
+            ctx.result("There was an error while exporting the camera recordings archive");
+        }
+    }
+
+    public static void onExportAllRecordingsRequest(Context ctx) {
+        logger.info("Exporting all recordings to a ZIP file");
+
+        try {
+            File allRecordingsZip = FrameRecorder.exportAll();
+
+            try (FileInputStream stream = new FileInputStream(allRecordingsZip)) {
+                logger.info("Uploading all recordings with size " + stream.available());
+
+                ctx.contentType("application/zip");
+                ctx.header(
+                        "Content-Disposition",
+                        "attachment; filename=\"" + "photonvision-recordings-export.zip\"");
+
+                ctx.result(stream);
+                ctx.status(200);
+            } finally {
+                if (allRecordingsZip.exists()) {
+                    allRecordingsZip.delete();
+                }
+            }
+        } catch (Exception e) {
+            logger.error("Unable to export archive of all recordings", e);
+            ctx.status(500);
+            ctx.result("There was an error while exporting the archive of all recordings");
+        }
+    }
+
+    private record DeleteRecordingRequest(String[] recordings, String cameraUniqueName) {}
+
+    public static void onDeleteRecordingRequest(Context ctx) {
+        try {
+            DeleteRecordingRequest request =
+                    kObjectMapper.readValue(ctx.body(), DeleteRecordingRequest.class);
+
+            Path recordingsRoot = ConfigManager.getInstance().getRecordingsDirectory().toPath();
+            for (String recording : request.recordings) {
+                Path rec;
+                try {
+                    rec = PathSafety.safeResolve(recordingsRoot, request.cameraUniqueName, recording);
+                } catch (SecurityException e) {
+                    ctx.status(400).result("Invalid camera or recording name");
+                    logger.error("Rejected unsafe delete path: " + e.getMessage());
+                    return;
+                }
+                FileUtils.deleteDirectory(rec.toFile());
+            }
+
+            ctx.status(200);
+            ctx.result("Successfully deleted recording(s): " + request.recordings.toString());
+            logger.info("Successfully deleted recording(s): " + request.recordings.toString());
+        } catch (JsonProcessingException e) {
+            ctx.status(400).result("Invalid JSON format");
+            logger.error("Failed to delete recording(s)", e);
+        } catch (Exception e) {
+            ctx.status(500).result("Failed to delete recording(s)");
+            logger.error("Unexpected error while attempting to delete recording(s)", e);
+        }
+    }
+
+    public static void onNukeRecordingsRequest(Context ctx) {
+        try {
+            FileUtils.deleteDirectory(ConfigManager.getInstance().getRecordingsDirectory());
+
+            ctx.status(200);
+            ctx.result("Successfully deleted all recordings");
+            logger.info("Successfully deleted all recordings");
+        } catch (Exception e) {
+            ctx.status(500).result("Failed to delete all recordings");
+            logger.error("Unexpected error while attempting to delete all recordings", e);
+        }
+    }
+
+    private record StartReplayRequest(String cameraUniqueName, String recording) {}
+
+    /**
+     * Start a file-log replay on the live camera identified by {@code cameraUniqueName}. The
+     * recording lives at {@code <recordingsDir>/<cameraUniqueName>/<recording>}; the live frame
+     * provider is swapped for a FileLogFrameProvider for the duration of the replay (see
+     * VisionModule.startReplay). Returns 202 immediately — the swap and pipeline run asynchronously,
+     * and progress is published over NT and the websocket.
+     */
+    public static void onStartReplayRequest(Context ctx) {
+        try {
+            StartReplayRequest request = kObjectMapper.readValue(ctx.body(), StartReplayRequest.class);
+            if (request.cameraUniqueName == null || request.cameraUniqueName.isEmpty()) {
+                ctx.status(400).result("cameraUniqueName is required");
+                return;
+            }
+            if (request.recording == null || request.recording.isEmpty()) {
+                ctx.status(400).result("recording is required");
+                return;
+            }
+
+            var module = VisionSourceManager.getInstance().vmm.getModule(request.cameraUniqueName);
+            if (module == null) {
+                ctx.status(404).result("No camera with uniqueName=" + request.cameraUniqueName);
+                return;
+            }
+
+            Path recordingDir;
+            try {
+                recordingDir =
+                        PathSafety.safeResolve(
+                                ConfigManager.getInstance().getRecordingsDirectory().toPath(),
+                                request.cameraUniqueName,
+                                request.recording);
+            } catch (SecurityException e) {
+                ctx.status(400).result("Invalid camera or recording name");
+                logger.error("Rejected unsafe replay path: " + e.getMessage());
+                return;
+            }
+            if (!recordingDir.toFile().isDirectory()) {
+                ctx.status(404).result("Recording not found at " + recordingDir);
+                return;
+            }
+
+            try {
+                module.startReplay(recordingDir);
+            } catch (IllegalStateException alreadyReplaying) {
+                ctx.status(409).result(alreadyReplaying.getMessage());
+                return;
+            } catch (IOException badRecording) {
+                ctx.status(400).result("Recording is malformed: " + badRecording.getMessage());
+                logger.warn("Replay rejected (malformed recording): " + badRecording.getMessage());
+                return;
+            }
+
+            ctx.status(202).result("Replay started: " + request.recording);
+            logger.info("Started replay on " + request.cameraUniqueName + " from " + request.recording);
+        } catch (JsonProcessingException e) {
+            ctx.status(400).result("Invalid JSON format");
+        } catch (Exception e) {
+            logger.error("Unexpected error starting replay", e);
+            ctx.status(500).result("Unexpected error starting replay");
+        }
+    }
+
+    public static void onListResultsRequest(Context ctx) {
+        try {
+            String camera = ctx.queryParam("camera");
+            String recording = ctx.queryParam("recording");
+            if (camera == null || camera.isEmpty() || recording == null || recording.isEmpty()) {
+                ctx.status(400).result("camera and recording query params required");
+                return;
+            }
+            Path resultsDir;
+            try {
+                resultsDir =
+                        PathSafety.safeResolve(
+                                ConfigManager.getInstance().getRecordingsDirectory().toPath(),
+                                camera,
+                                recording,
+                                "results");
+            } catch (SecurityException e) {
+                ctx.status(400).result("Invalid camera or recording name");
+                return;
+            }
+            if (!resultsDir.toFile().isDirectory()) {
+                ctx.json(java.util.List.of());
+                return;
+            }
+            var out = new java.util.ArrayList<java.util.Map<String, Object>>();
+            try (var stream = java.nio.file.Files.list(resultsDir)) {
+                for (Path jsonl :
+                        stream.filter(p -> p.getFileName().toString().endsWith(".jsonl")).toList()) {
+                    var lines = java.nio.file.Files.readAllLines(jsonl);
+                    if (lines.isEmpty()) continue;
+                    var header = kObjectMapper.readTree(lines.get(0));
+                    String hash = jsonl.getFileName().toString();
+                    hash = hash.substring(0, hash.length() - ".jsonl".length());
+                    var row = new java.util.LinkedHashMap<String, Object>();
+                    row.put("hash", hash);
+                    row.put("sizeBytes", java.nio.file.Files.size(jsonl));
+                    row.put("resultCount", lines.size() - 1);
+                    row.put("pipelineType", header.path("pipeline_type").asText("unknown"));
+                    row.put(
+                            "tssActiveAtRecord",
+                            header.has("tss_active_at_record")
+                                    && header.get("tss_active_at_record").asBoolean(false));
+                    row.put("mtimeMillis", jsonl.toFile().lastModified());
+                    out.add(row);
+                }
+            }
+            ctx.json(out);
+        } catch (Exception e) {
+            logger.error("Failed to list recording results", e);
+            ctx.status(500).result("Failed to list results");
+        }
+    }
+
+    public static void onDownloadResultRequest(Context ctx) {
+        try {
+            String camera = ctx.queryParam("camera");
+            String recording = ctx.queryParam("recording");
+            String hash = ctx.queryParam("hash");
+            if (camera == null
+                    || camera.isEmpty()
+                    || recording == null
+                    || recording.isEmpty()
+                    || hash == null
+                    || hash.isEmpty()) {
+                ctx.status(400).result("camera, recording, and hash query params required");
+                return;
+            }
+            Path jsonl;
+            try {
+                jsonl =
+                        PathSafety.safeResolve(
+                                ConfigManager.getInstance().getRecordingsDirectory().toPath(),
+                                camera,
+                                recording,
+                                "results",
+                                hash + ".jsonl");
+            } catch (SecurityException e) {
+                ctx.status(400).result("Invalid camera/recording/hash");
+                return;
+            }
+            if (!jsonl.toFile().isFile()) {
+                ctx.status(404).result("Result not found");
+                return;
+            }
+            byte[] bytes = java.nio.file.Files.readAllBytes(jsonl);
+            String nickname =
+                    java.util.Optional.ofNullable(
+                                    ConfigManager.getInstance().getConfig().getCameraConfigurations().get(camera))
+                            .map(c -> c.nickname)
+                            .filter(s -> s != null && !s.isBlank())
+                            .orElse(camera);
+            ctx.contentType("application/json");
+            ctx.header(
+                    "Content-Disposition",
+                    "attachment; filename=\""
+                            + sanitizeForFilename(nickname)
+                            + "_"
+                            + recording
+                            + "_"
+                            + hash
+                            + ".jsonl\"");
+            ctx.result(bytes);
+        } catch (Exception e) {
+            logger.error("Failed to download recording result", e);
+            ctx.status(500).result("Failed to download result");
+        }
+    }
+
+    /**
+     * Lists active replays across all cameras so the UI can poll for a banner / preview /
+     * auto-download trigger without taking a dependency on PV's NT websocket bridge.
+     */
+    public static void onReplayStatusRequest(Context ctx) {
+        try {
+            var modules = VisionSourceManager.getInstance().vmm.getModules();
+            var rows = new java.util.ArrayList<java.util.Map<String, Object>>();
+            for (var module : modules) {
+                var status = module.getReplayStatus();
+                if (!status.isReplaying()) continue;
+                var row = new java.util.LinkedHashMap<String, Object>();
+                row.put("cameraUniqueName", module.uniqueName());
+                row.put("recordingName", status.recordingName());
+                row.put("currentFrame", status.currentFrame());
+                row.put("totalFrames", status.totalFrames());
+                rows.add(row);
+            }
+            ctx.json(rows);
+        } catch (Exception e) {
+            logger.error("Failed to read replay status", e);
+            ctx.status(500).result("Failed to read replay status");
+        }
+    }
+
+    public static void onCancelReplayRequest(Context ctx) {
+        try {
+            CommonCameraUniqueName request =
+                    kObjectMapper.readValue(ctx.body(), CommonCameraUniqueName.class);
+            if (request.cameraUniqueName == null || request.cameraUniqueName.isEmpty()) {
+                ctx.status(400).result("cameraUniqueName is required");
+                return;
+            }
+            var module = VisionSourceManager.getInstance().vmm.getModule(request.cameraUniqueName);
+            if (module == null) {
+                ctx.status(404).result("No camera with uniqueName=" + request.cameraUniqueName);
+                return;
+            }
+            module.cancelReplay();
+            ctx.status(200).result("Replay cancel requested");
+            logger.info("Cancelled replay on " + request.cameraUniqueName);
+        } catch (JsonProcessingException e) {
+            ctx.status(400).result("Invalid JSON format");
+        } catch (Exception e) {
+            logger.error("Unexpected error cancelling replay", e);
+            ctx.status(500).result("Unexpected error cancelling replay");
+        }
+    }
 }
diff --git a/photon-server/src/main/java/org/photonvision/server/Server.java b/photon-server/src/main/java/org/photonvision/server/Server.java
index 573592a183..ff728e8775 100644
--- a/photon-server/src/main/java/org/photonvision/server/Server.java
+++ b/photon-server/src/main/java/org/photonvision/server/Server.java
@@ -163,8 +163,19 @@ private static void start(int port) {
         app.post("/api/objectdetection/rename", RequestHandler::onRenameObjectDetectionModelRequest);
         app.post("/api/objectdetection/nuke", RequestHandler::onNukeObjectDetectionModelsRequest);
 
-        /* Testing API Events */
+        // Recordings
+        app.get("/api/recordings/exportIndividual", RequestHandler::onExportIndividualRecordingRequest);
+        app.get("/api/recordings/exportCamera", RequestHandler::onExportCameraRecordingsRequest);
+        app.get("/api/recordings/export", RequestHandler::onExportAllRecordingsRequest);
+        app.post("/api/recordings/delete", RequestHandler::onDeleteRecordingRequest);
+        app.post("/api/recordings/nuke", RequestHandler::onNukeRecordingsRequest);
+        app.post("/api/recordings/replay", RequestHandler::onStartReplayRequest);
+        app.post("/api/recordings/replay/cancel", RequestHandler::onCancelReplayRequest);
+        app.get("/api/recordings/replay/status", RequestHandler::onReplayStatusRequest);
+        app.get("/api/recordings/results", RequestHandler::onListResultsRequest);
+        app.get("/api/recordings/result", RequestHandler::onDownloadResultRequest);
 
+        /* Testing API Events */
         app.post("/api/test/resetBackend", TestRequestHandler::handleResetRequest);
 
         app.post("/api/test/activateTestMode", TestRequestHandler::testMode);
diff --git a/photon-targeting/src/main/java/org/photonvision/common/networktables/NTTopicSet.java b/photon-targeting/src/main/java/org/photonvision/common/networktables/NTTopicSet.java
index 4e7354ce9d..6bc53f4887 100644
--- a/photon-targeting/src/main/java/org/photonvision/common/networktables/NTTopicSet.java
+++ b/photon-targeting/src/main/java/org/photonvision/common/networktables/NTTopicSet.java
@@ -54,6 +54,9 @@ public class NTTopicSet {
     public BooleanPublisher driverModePublisher;
     public BooleanSubscriber driverModeSubscriber;
 
+    public BooleanTopic recordingEntry;
+    public BooleanPublisher recordingPublisher;
+    public BooleanSubscriber recordingSubscriber;
     public IntegerPublisher fpsLimitPublisher;
     public IntegerSubscriber fpsLimitSubscriber;
 
@@ -104,6 +107,10 @@ public void updateEntries() {
         // Fun little hack to make the request show up
         driverModeSubscriber.getTopic().publish().setDefault(false);
 
+        recordingPublisher = subTable.getBooleanTopic("recording").publish();
+        recordingSubscriber = subTable.getBooleanTopic("recordingRequest").subscribe(false);
+
+        recordingSubscriber.getTopic().publish().setDefault(false);
         fpsLimitPublisher = subTable.getIntegerTopic("fpsLimit").publish();
         fpsLimitSubscriber = subTable.getIntegerTopic("fpsLimitRequest").subscribe(-1);
 
@@ -138,6 +145,8 @@ public void removeEntries() {
         if (driverModePublisher != null) driverModePublisher.close();
         if (driverModeSubscriber != null) driverModeSubscriber.close();
 
+        if (recordingPublisher != null) recordingPublisher.close();
+        if (recordingSubscriber != null) recordingSubscriber.close();
         if (fpsLimitPublisher != null) fpsLimitPublisher.close();
         if (fpsLimitSubscriber != null) fpsLimitSubscriber.close();
 
diff --git a/photon-targeting/src/main/native/include/photon/networktables/NTTopicSet.h b/photon-targeting/src/main/native/include/photon/networktables/NTTopicSet.h
index c5a8957fdd..8f555261e2 100644
--- a/photon-targeting/src/main/native/include/photon/networktables/NTTopicSet.h
+++ b/photon-targeting/src/main/native/include/photon/networktables/NTTopicSet.h
@@ -46,6 +46,10 @@ class NTTopicSet {
   wpi::nt::BooleanPublisher driverModePublisher;
   wpi::nt::BooleanSubscriber driverModeSubscriber;
 
+  wpi::nt::BooleanTopic recordingEntry;
+  wpi::nt::BooleanPublisher recordingPublisher;
+  wpi::nt::BooleanSubscriber recordingSubscriber;
+
   wpi::nt::DoublePublisher latencyMillisEntry;
   wpi::nt::BooleanPublisher hasTargetEntry;
   wpi::nt::DoublePublisher targetPitchEntry;
@@ -81,6 +85,12 @@ class NTTopicSet {
 
     driverModeSubscriber.GetTopic().Publish().SetDefault(false);
 
+    recordingPublisher = subTable->GetBooleanTopic("recording").Publish();
+    recordingSubscriber =
+        subTable->GetBooleanTopic("recordingRequest").Subscribe(0);
+
+    recordingSubscriber.GetTopic().Publish().SetDefault(false);
+
     latencyMillisEntry = subTable->GetDoubleTopic("latencyMillis").Publish();
     hasTargetEntry = subTable->GetBooleanTopic("hasTargets").Publish();