diff --git a/client/dive-common/alignedTimeline.spec.ts b/client/dive-common/alignedTimeline.spec.ts
index d0d0520fb..821c9b09e 100644
--- a/client/dive-common/alignedTimeline.spec.ts
+++ b/client/dive-common/alignedTimeline.spec.ts
@@ -1,6 +1,7 @@
 import type { FrameImage } from './apispec';
 import {
-  buildAlignedTimeline, buildInverseAlignedIndex, canAlign, computeGapGradient, computeGapSlots,
+  buildAlignedTimeline, buildInverseAlignedIndex, buildOffsetTimeline, canAlign,
+  computeGapGradient, computeGapSlots,
 } from './alignedTimeline';
 
 function frame(timestamp?: number): FrameImage {
@@ -209,3 +210,64 @@ describe('alignedTimeline', () => {
     });
   });
 });
+
+/**
+ * Fixed-rig start offsets: the case timestamps can't cover, because video
+ * frames carry none. EO/IR pairs from the same fixed rig are recorded by
+ * independent encoders, so one can start a fraction of a second after the
+ * other; that lag is constant for the whole recording.
+ */
+describe('buildOffsetTimeline', () => {
+  it('pairs a later-starting camera with the reference instant', () => {
+    // B starts 2 frames later: B's frame 2 is the same instant as A's 0.
+    const result = buildOffsetTimeline({ A: 5, B: 5 }, { A: 0, B: 2 });
+    if (!result.aligned) throw new Error('expected aligned');
+    // Slot 0 is the earliest instant ANY camera saw: B's frame 0, before A began.
+    expect(result.slots[0]).toEqual({ A: undefined, B: 0 });
+    expect(result.slots[2]).toEqual({ A: 0, B: 2 });
+    expect(result.slots[4]).toEqual({ A: 2, B: 4 });
+  });
+
+  it('keeps the union, blanking each camera outside its own coverage', () => {
+    const result = buildOffsetTimeline({ A: 3, B: 3 }, { A: 0, B: 2 });
+    if (!result.aligned) throw new Error('expected aligned');
+    // 2 leading slots before A starts + 3 shared + 0 trailing.
+    expect(result.slots).toHaveLength(5);
+    expect(computeGapSlots(result.slots)).toEqual([0, 1, 3, 4]);
+    // The overlap in the middle has both cameras.
+    expect(result.slots[2]).toEqual({ A: 0, B: 2 });
+  });
+
+  it('round-trips through the inverse index the resolver uses', () => {
+    const result = buildOffsetTimeline({ A: 4, B: 4 }, { A: 0, B: 1 });
+    if (!result.aligned) throw new Error('expected aligned');
+    const inverse = buildInverseAlignedIndex(result.slots);
+    // Whatever slot holds A's frame 2 must hold B's frame 3 -- the same instant.
+    const slotForA2 = inverse.A.get(2) as number;
+    expect(result.slots[slotForA2].B).toBe(3);
+    expect(inverse.B.get(3)).toBe(slotForA2);
+  });
+
+  it('handles a negative offset (reference is the later camera)', () => {
+    const result = buildOffsetTimeline({ A: 4, B: 4 }, { A: 0, B: -1 });
+    if (!result.aligned) throw new Error('expected aligned');
+    expect(result.slots[1]).toEqual({ A: 1, B: 0 });
+  });
+
+  it('declines when nothing needs correcting or there is no pair', () => {
+    // All-zero offsets: the positional path already does this, more cheaply.
+    expect(buildOffsetTimeline({ A: 5, B: 5 }, { A: 0, B: 0 })).toEqual({ aligned: false });
+    // A camera with no frames loaded can't be aligned against.
+    expect(buildOffsetTimeline({ A: 5, B: 0 }, { A: 0, B: 2 })).toEqual({ aligned: false });
+    expect(buildOffsetTimeline({ A: 5 }, { A: 3 })).toEqual({ aligned: false });
+  });
+
+  it('treats a missing camera entry as no offset', () => {
+    // A is absent from the offsets map, so it behaves as A: 0 -- identical to
+    // { A: 0, B: 1 }: one leading slot for B's frame 0, then the pairs.
+    const result = buildOffsetTimeline({ A: 3, B: 3 }, { B: 1 });
+    if (!result.aligned) throw new Error('expected aligned');
+    expect(result.slots[0]).toEqual({ A: undefined, B: 0 });
+    expect(result.slots[1]).toEqual({ A: 0, B: 1 });
+  });
+});
diff --git a/client/dive-common/alignedTimeline.ts b/client/dive-common/alignedTimeline.ts
index 750566003..08f3d4934 100644
--- a/client/dive-common/alignedTimeline.ts
+++ b/client/dive-common/alignedTimeline.ts
@@ -210,3 +210,71 @@ export function computeGapSlots(slots: AlignedSlot[]): number[] {
   });
   return gaps;
 }
+
+/**
+ * A camera's constant start offset, in its own frames: local frame
+ * `slot + offset` shows the same instant as the reference camera's frame
+ * `slot`. A positive offset means this camera starts LATER -- its frame 0
+ * happens before the reference's frame 0, so it must be read further in.
+ */
+export type CameraFrameOffsets = Record<string, number>;
+
+/**
+ * Build a timeline from fixed per-camera start offsets rather than per-frame
+ * timestamps.
+ *
+ * buildAlignedTimeline needs a timestamp on every frame, which only image
+ * sequences carry (parsed from filenames) -- video panes never qualify, so
+ * they scrub in raw-index lockstep and any recording start offset between
+ * two cameras is baked into the review. On a fixed rig that offset is a
+ * single constant, so one number per camera is enough to line them up, and
+ * emitting it as slots means everything downstream (pane seek, gap
+ * indication, cross-camera frame translation) behaves exactly as it does
+ * for a timestamp-aligned dataset.
+ *
+ * Slots span the UNION of the cameras' coverage: where one camera has run
+ * out (or has not started), its entry is undefined, which the existing gap
+ * handling already renders and blanks correctly, rather than silently
+ * trimming footage off the ends.
+ *
+ * Returns { aligned: false } when fewer than two cameras have frames, or
+ * when every offset is zero -- there is nothing to correct then, so the
+ * caller should stay on the cheaper positional path.
+ */
+export function buildOffsetTimeline(
+  cameraFrameCounts: Record<string, number>,
+  offsets: CameraFrameOffsets,
+): TimelineResult {
+  const cameras = Object.keys(cameraFrameCounts)
+    .filter((camera) => cameraFrameCounts[camera] > 0);
+  if (cameras.length < 2) {
+    return { aligned: false };
+  }
+  if (cameras.every((camera) => (offsets[camera] ?? 0) === 0)) {
+    return { aligned: false };
+  }
+  // Slot s shows camera c's local frame s + offset[c]; that frame exists for
+  // s in [-offset[c], count[c] - offset[c]). Take the union across cameras,
+  // then rebase so the emitted slot array is 0-based.
+  const starts = cameras.map((camera) => -(offsets[camera] ?? 0));
+  const ends = cameras.map(
+    (camera) => cameraFrameCounts[camera] - (offsets[camera] ?? 0),
+  );
+  const base = Math.min(...starts);
+  const total = Math.max(...ends) - base;
+  if (total <= 0) {
+    return { aligned: false };
+  }
+  const slots: AlignedSlot[] = new Array(total);
+  for (let index = 0; index < total; index += 1) {
+    const slot: AlignedSlot = {};
+    cameras.forEach((camera) => {
+      const local = index + base + (offsets[camera] ?? 0);
+      slot[camera] = local >= 0 && local < cameraFrameCounts[camera]
+        ? local
+        : undefined;
+    });
+    slots[index] = slot;
+  }
+  return { aligned: true, slots };
+}
diff --git a/client/dive-common/apispec.ts b/client/dive-common/apispec.ts
index 977006bdd..4b4b79b0c 100644
--- a/client/dive-common/apispec.ts
+++ b/client/dive-common/apispec.ts
@@ -199,6 +199,19 @@ interface SaveDetectionsArgs {
   set?: string;
 }
 
+/** Outcome of shifting one camera's stored annotations onto its time offset. */
+interface CameraFrameOffsetResult {
+  camera: string;
+  /** The camera's start offset in its own frames, now both stored and applied. */
+  offset: number;
+  /** Frames the annotations actually moved: the offset minus what was already applied. */
+  delta: number;
+  tracks: number;
+  groups: number;
+  /** Annotations that had nothing left before frame 0 and were deleted. */
+  dropped: number;
+}
+
 interface SaveAttributeArgs {
   delete: string[];
   upsert: Attribute[];
@@ -332,9 +345,13 @@ interface DatasetConfigMutable {
    * role are absent.
    */
   cameraRoles?: Record<string, CameraRole>;
+  /** Per-camera start offset in its own frames, for recorders that started at different times. */
+  cameraFrameOffsets?: Record<string, number>;
+  /** The part of cameraFrameOffsets already applied to each camera's annotations. */
+  cameraFrameOffsetsApplied?: Record<string, number>;
   error?: string;
 }
-const DatasetConfigMutableKeys = ['attributes', 'confidenceFilters', 'timeFilters', 'imageEnhancements', 'customTypeStyling', 'customGroupStyling', 'attributeTrackFilters', 'datasetInfo', 'cameraHomographies', 'cameraCorrespondences', 'cameraTransformTypes', 'cameraRegistrationSource', 'typeHierarchy', 'taxonomySources', 'cameraRoles'];
+const DatasetConfigMutableKeys = ['attributes', 'confidenceFilters', 'timeFilters', 'imageEnhancements', 'customTypeStyling', 'customGroupStyling', 'attributeTrackFilters', 'datasetInfo', 'cameraHomographies', 'cameraCorrespondences', 'cameraTransformTypes', 'cameraRegistrationSource', 'cameraFrameOffsets', 'cameraFrameOffsetsApplied', 'typeHierarchy', 'taxonomySources', 'cameraRoles'];
 /**
  * Cross-dataset color/style overrides, reused across every dataset when the
  * "shared" color scope is enabled (see clientSettings.typeSettings.colorScope).
@@ -517,6 +534,13 @@ interface Api {
 
   saveDetections(datasetId: string, args: SaveDetectionsArgs): Promise<unknown>;
   saveConfig(datasetId: string, config: DatasetConfigMutable): Promise<unknown>;
+  /**
+   * Shift one camera's stored annotations onto its time offset, in persistence.
+   * Only the part not yet applied moves; the caller reloads the camera afterwards.
+   */
+  applyCameraFrameOffset(
+    datasetId: string, camera: string, offset: number,
+  ): Promise<CameraFrameOffsetResult>;
   saveAttributes(datasetId: string, args: SaveAttributeArgs): Promise<unknown>;
   saveAttributeTrackFilters(datasetId: string,
     args: SaveAttributeTrackFilterArgs): Promise<unknown>;
@@ -931,6 +955,7 @@ export type {
   PipeMetadata,
   Pipelines,
   SaveDetectionsArgs,
+  CameraFrameOffsetResult,
   SaveAttributeArgs,
   SaveAttributeTrackFilterArgs,
   TrainingConfig,
diff --git a/client/dive-common/components/CameraRegistration/RegistrationTools.vue b/client/dive-common/components/CameraRegistration/RegistrationTools.vue
index 619426bce..60a89546c 100644
--- a/client/dive-common/components/CameraRegistration/RegistrationTools.vue
+++ b/client/dive-common/components/CameraRegistration/RegistrationTools.vue
@@ -648,6 +648,8 @@ export default defineComponent({
           cameraCorrespondences: registration.observations.value,
           cameraTransformTypes: registration.transformTypes.value,
           cameraRegistrationSource: registration.source.value,
+          cameraFrameOffsets: registration.frameOffsets.value,
+          cameraFrameOffsetsApplied: registration.appliedFrameOffsets.value,
         });
         registration.markSaved();
       } finally {
diff --git a/client/dive-common/components/DatasetInfo/DatasetInfo.spec.ts b/client/dive-common/components/DatasetInfo/DatasetInfo.spec.ts
index 76bedc8c5..93737a126 100644
--- a/client/dive-common/components/DatasetInfo/DatasetInfo.spec.ts
+++ b/client/dive-common/components/DatasetInfo/DatasetInfo.spec.ts
@@ -84,6 +84,9 @@ function apiWithMetadata({
     loadFrameMetadata: vi.fn(async () => frameMetadata),
     saveDetections: async () => undefined,
     saveConfig: async () => undefined,
+    applyCameraFrameOffset: async () => ({
+      camera: '', offset: 0, delta: 0, tracks: 0, groups: 0, dropped: 0,
+    }),
     saveAttributes: async () => undefined,
     saveAttributeTrackFilters: async () => undefined,
     openFromDisk: async () => ({ canceled: true, filePaths: [] }),
diff --git a/client/dive-common/components/ImportAnnotations.vue b/client/dive-common/components/ImportAnnotations.vue
index 2b34a4082..4f8c9bf2f 100644
--- a/client/dive-common/components/ImportAnnotations.vue
+++ b/client/dive-common/components/ImportAnnotations.vue
@@ -340,6 +340,7 @@ export default defineComponent({
           meta.cameraCorrespondences,
           meta.cameraTransformTypes,
           meta.cameraRegistrationSource,
+          meta.cameraFrameOffsets,
         );
         if (priorPair) {
           // The panel is open: re-select the imported pair (falling back to
diff --git a/client/dive-common/components/MultiCamTools.spec.ts b/client/dive-common/components/MultiCamTools.spec.ts
new file mode 100644
index 000000000..a6ca9ccdc
--- /dev/null
+++ b/client/dive-common/components/MultiCamTools.spec.ts
@@ -0,0 +1,55 @@
+import { defineComponent, h, ref } from 'vue';
+import { shallowMount } from '@vue/test-utils';
+import MultiCamTools from './MultiCamTools.vue';
+
+const state = vi.hoisted(() => ({
+  readOnlyMode: false,
+  offsetEditLock: false,
+}));
+
+vi.mock('dive-common/apispec', () => ({
+  useApi: () => ({ applyCameraFrameOffset: vi.fn() }),
+}));
+
+vi.mock('vue-media-annotator/provides', () => ({
+  useSelectedCamera: () => ref('left'),
+  useEditingMode: () => ref(false),
+  useTrackFilters: () => ({ enabledAnnotations: ref([]) }),
+  useHandler: () => ({ save: vi.fn(), reloadCameraAnnotations: vi.fn() }),
+  useTime: () => ({ frame: ref(0), frameRate: ref(30) }),
+  useSelectedTrackId: () => ref(null),
+  useCameraStore: () => ({ orderedCameraNames: () => ['left', 'right'] }),
+  useCameraRegistration: () => ({
+    frameOffsets: ref({ right: 3 }),
+    appliedFrameOffsets: ref({}),
+  }),
+  useDatasetId: () => ref('dataset'),
+  usePendingSaveCount: () => ref(0),
+  useReadOnlyMode: () => ref(state.readOnlyMode),
+  useOffsetEditLock: () => ref(state.offsetEditLock),
+}));
+
+function applyButton() {
+  const Host = defineComponent({ setup: () => () => h(MultiCamTools) });
+  const wrapper = shallowMount(Host, { stubs: { MultiCamTools: false } });
+  const button = wrapper.findAll('v-btn').wrappers
+    .find((b) => b.text().includes('Apply to annotations'));
+  if (!button) throw new Error('Apply to annotations button not rendered');
+  return { wrapper, button };
+}
+
+it('keeps Apply enabled when editing is paused only by the pending offset', () => {
+  state.readOnlyMode = true;
+  state.offsetEditLock = true;
+  const { wrapper, button } = applyButton();
+  expect(button.attributes('disabled')).toBeUndefined();
+  expect(wrapper.text()).toContain('Annotation editing is paused until the offset is applied.');
+});
+
+it('disables Apply in a truly read-only view', () => {
+  state.readOnlyMode = true;
+  state.offsetEditLock = false;
+  const { wrapper, button } = applyButton();
+  expect(button.attributes('disabled')).toBeDefined();
+  expect(wrapper.text()).not.toContain('Annotation editing is paused');
+});
diff --git a/client/dive-common/components/MultiCamTools.vue b/client/dive-common/components/MultiCamTools.vue
index dec6e513c..3e1e9a6ca 100644
--- a/client/dive-common/components/MultiCamTools.vue
+++ b/client/dive-common/components/MultiCamTools.vue
@@ -1,9 +1,14 @@
 <script lang="ts">
 import { computed, defineComponent, ref } from 'vue';
 import {
+  useCameraRegistration,
   useCameraStore,
+  useDatasetId,
   useEditingMode,
   useHandler,
+  useOffsetEditLock,
+  usePendingSaveCount,
+  useReadOnlyMode,
   useSelectedCamera,
   useSelectedTrackId,
   useTime,
@@ -11,6 +16,8 @@ import {
 } from 'vue-media-annotator/provides';
 import TooltipBtn from 'vue-media-annotator/components/TooltipButton.vue';
 import { AnnotationId } from 'vue-media-annotator/BaseAnnotation';
+import { useApi } from 'dive-common/apispec';
+import { pendingFrameShifts } from 'dive-common/frameOffsetAnnotations';
 
 interface CameraTrackData {
   trackExists: boolean;
@@ -25,10 +32,80 @@ export default defineComponent({
     const inEditingMode = useEditingMode();
     const enabledTracksRef = useTrackFilters().enabledAnnotations;
     const handler = useHandler();
-    const { frame } = useTime();
+    const { frame, frameRate } = useTime();
     const selectedTrackId = useSelectedTrackId();
     const cameraStore = useCameraStore();
     const cameras = computed(() => cameraStore.orderedCameraNames());
+    const registration = useCameraRegistration();
+    const datasetId = useDatasetId();
+    const pendingSaveCount = usePendingSaveCount();
+    const readOnlyMode = useReadOnlyMode();
+    const offsetEditLock = useOffsetEditLock();
+    const { applyCameraFrameOffset } = useApi();
+
+    // Time offset: the first camera is the reference; every other camera is shifted onto it.
+    const OFFSET_LIMIT_SECONDS = 10;
+    const referenceCamera = computed(() => cameras.value[0] ?? null);
+    const offsetCameras = computed(() => cameras.value.slice(1));
+    const offsetLimit = computed(
+      () => Math.max(1, Math.round((frameRate.value || 30) * OFFSET_LIMIT_SECONDS)),
+    );
+    function cameraOffset(camera: string): number {
+      return registration.frameOffsets.value[camera] ?? 0;
+    }
+    function setCameraOffset(camera: string, value: number) {
+      // Replace the map: the aligned timeline is a computed over this ref.
+      registration.frameOffsets.value = {
+        ...registration.frameOffsets.value,
+        [camera]: Math.round(value),
+      };
+    }
+    function nudgeOffset(camera: string, delta: number) {
+      setCameraOffset(camera, cameraOffset(camera) + delta);
+    }
+    function offsetReadout(camera: string): string {
+      const frames = cameraOffset(camera);
+      const sign = frames > 0 ? '+' : '';
+      const plural = Math.abs(frames) === 1 ? '' : 's';
+      const seconds = frameRate.value ? ` (${sign}${(frames / frameRate.value).toFixed(3)}s)` : '';
+      return `${sign}${frames} frame${plural}${seconds}`;
+    }
+    const pendingShifts = computed(() => pendingFrameShifts(
+      registration.frameOffsets.value,
+      registration.appliedFrameOffsets.value,
+      offsetCameras.value,
+    ));
+    const savingOffsets = ref(false);
+    /**
+     * Shift each pending camera's stored annotations on the server, then
+     * reload that camera. Persistence does the rewrite so the page never
+     * walks or uploads the whole dataset.
+     */
+    async function saveAnnotationOffsets() {
+      savingOffsets.value = true;
+      try {
+        // The shift applies to what is stored, so unsaved edits go first.
+        if (pendingSaveCount.value > 0) {
+          await handler.save();
+        }
+        const pending = Object.keys(pendingShifts.value);
+        for (let i = 0; i < pending.length; i += 1) {
+          const camera = pending[i];
+          const offset = cameraOffset(camera);
+          // eslint-disable-next-line no-await-in-loop
+          await applyCameraFrameOffset(datasetId.value, camera, offset);
+          registration.appliedFrameOffsets.value = {
+            ...registration.appliedFrameOffsets.value,
+            [camera]: offset,
+          };
+          registration.markFrameOffsetSaved(camera, offset);
+          // eslint-disable-next-line no-await-in-loop
+          await handler.reloadCameraAnnotations(camera);
+        }
+      } finally {
+        savingOffsets.value = false;
+      }
+    }
     const canary = ref(false);
     function _depend(): boolean {
       return canary.value;
@@ -119,6 +196,18 @@ export default defineComponent({
       deleteTrack,
       startLinking,
       handler,
+      referenceCamera,
+      offsetCameras,
+      offsetLimit,
+      cameraOffset,
+      setCameraOffset,
+      nudgeOffset,
+      offsetReadout,
+      pendingShifts,
+      savingOffsets,
+      saveAnnotationOffsets,
+      readOnlyMode,
+      offsetEditLock,
     };
   },
 });
@@ -130,6 +219,59 @@ export default defineComponent({
       Multi Camera Tools for creating tracks, linking and unlinking tracks
     </span>
     <v-divider class="my-3" />
+    <div v-if="offsetCameras.length">
+      <h4>Time Offset</h4>
+      <span class="text-caption grey--text d-block mb-1">
+        Frames to shift each camera so it plays in step with {{ referenceCamera }}.
+      </span>
+      <div v-for="camera in offsetCameras" :key="camera" class="mb-2">
+        <span class="text-body-2">{{ camera }}</span>
+        <div class="d-flex align-center">
+          <tooltip-btn
+            icon="mdi-minus"
+            :tooltip-text="`Shift ${camera} one frame earlier`"
+            @click="nudgeOffset(camera, -1)"
+          />
+          <v-slider
+            :value="cameraOffset(camera)"
+            :min="-offsetLimit"
+            :max="offsetLimit"
+            :step="1"
+            dense
+            hide-details
+            class="mx-1"
+            @input="setCameraOffset(camera, $event)"
+          />
+          <tooltip-btn
+            icon="mdi-plus"
+            :tooltip-text="`Shift ${camera} one frame later`"
+            @click="nudgeOffset(camera, 1)"
+          />
+        </div>
+        <div class="text-caption" style="font-family: monospace;">
+          {{ offsetReadout(camera) }}
+        </div>
+      </div>
+      <v-btn
+        block
+        small
+        color="primary"
+        :disabled="(readOnlyMode && !offsetEditLock) || !Object.keys(pendingShifts).length"
+        :loading="savingOffsets"
+        @click="saveAnnotationOffsets"
+      >
+        Apply to annotations
+      </v-btn>
+      <span class="text-caption grey--text d-block mt-1">
+        Moves every stored annotation on a shifted camera by its offset.
+      </span>
+      <span
+        v-if="offsetEditLock"
+        class="text-caption warning--text d-block mt-1"
+      >
+        Annotation editing is paused until the offset is applied.
+      </span>
+    </div>
     <v-divider class="my-3" />
     <div v-if="selectedTrackId !== null">
       <span> Selected Track: {{ selectedTrackId }} Frame: {{ frame }}</span>
diff --git a/client/dive-common/components/Viewer.vue b/client/dive-common/components/Viewer.vue
index 030b969d8..630bde18f 100644
--- a/client/dive-common/components/Viewer.vue
+++ b/client/dive-common/components/Viewer.vue
@@ -77,7 +77,8 @@ import {
 } from 'dive-common/apispec';
 import { orderedMultiCamCameraNames } from 'dive-common/multicamDisplay';
 import {
-  buildAlignedTimeline, buildInverseAlignedIndex, computeGapSlots, TimelineResult,
+  buildAlignedTimeline, buildInverseAlignedIndex, buildOffsetTimeline, computeGapSlots,
+  TimelineResult,
 } from 'dive-common/alignedTimeline';
 import {
   computeOutputs,
@@ -94,6 +95,8 @@ import {
 import { usePrompt } from 'dive-common/vue-utilities/prompt-service';
 import context from 'dive-common/store/context';
 import { MarkChangesPendingFilter } from 'vue-media-annotator/BaseFilterControls';
+import { pendingFrameShifts } from 'dive-common/frameOffsetAnnotations';
+import { timelineRange, timelineFeatures } from 'dive-common/timelineTrack';
 import GroupSidebarVue from './GroupSidebar.vue';
 import MultiCamToolsVue from './MultiCamTools.vue';
 import RegistrationToolsVue from './CameraRegistration/RegistrationTools.vue';
@@ -241,6 +244,7 @@ export default defineComponent({
       onResize,
       clear: mediaControllerClear,
       setAlignedFrameResolver,
+      setAnnotationFrameShifts,
       setResetZoomOverride,
     } = useMediaController({ segmentationCursorLoading });
     const { time, updateTime, initialize: initTime } = useTimeObserver();
@@ -262,6 +266,9 @@ export default defineComponent({
       // with stale data from props, for example if a persistent store
       // like vuex is used to drive them.
       loaded: false,
+      // Every camera's media is known, so the panes can mount and start fetching
+      // video while the annotations are still being inserted.
+      mediaLoaded: false,
       // Tracks loaded
       progress: 0,
       // Total tracks
@@ -274,6 +281,26 @@ export default defineComponent({
      * always for singleCam datasets -- playback falls back to today's exact
      * positional (broadcast-same-index) behavior via useMediaController.ts.
      */
+    // Constructed here rather than beside the other aligned-view state below
+    // because the aligned timeline reads its frame offsets, and that watch
+    // runs immediately.
+    const cameraRegistration = new CameraRegistrationStore();
+    /**
+     * How many frames this camera has: its image list when it is an image
+     * sequence, otherwise the annotator's own maxFrame (video panes carry no
+     * imageData). Returns 0 before the pane has loaded.
+     */
+    function cameraFrameCount(camera: string): number {
+      const images = imageData.value[camera];
+      if (images && images.length) {
+        return images.length;
+      }
+      try {
+        return aggregateController.value.getController(camera).maxFrame.value + 1;
+      } catch {
+        return 0;
+      }
+    }
     const alignedTimeline = computed<TimelineResult>(() => {
       if (!progress.loaded || multiCamList.value.length < 2) {
         return { aligned: false };
@@ -286,8 +313,35 @@ export default defineComponent({
       multiCamList.value.forEach((camera) => {
         camerasFrames[camera] = imageData.value[camera] ?? [];
       });
+      // A reviewer's time offset wins over filename timestamps. Pipelines pair
+      // cameras by index, not by capture time, so annotations warped across a
+      // rig are index-aligned; the offset is the correction for that, and a
+      // timestamp timeline would show the images lined up while the slider
+      // moved only the boxes. Returns { aligned: false } when every offset is
+      // zero, so an uncorrected dataset keeps the timestamp path and its gap
+      // handling, or the cheaper positional path when there are none.
+      const frameCounts: Record<string, number> = {};
+      multiCamList.value.forEach((camera) => {
+        frameCounts[camera] = cameraFrameCount(camera);
+      });
+      const byOffset = buildOffsetTimeline(frameCounts, cameraRegistration.frameOffsets.value);
+      if (byOffset.aligned) {
+        return byOffset;
+      }
       return buildAlignedTimeline(camerasFrames);
     });
+    // Until an offset is applied to a camera's annotations, they stay put while its video shifts.
+    const pendingAnnotationShifts = computed(() => pendingFrameShifts(
+      cameraRegistration.frameOffsets.value,
+      cameraRegistration.appliedFrameOffsets.value,
+      multiCamList.value,
+    ));
+    watch(pendingAnnotationShifts, (shifts) => setAnnotationFrameShifts(shifts), { immediate: true });
+    // Edits key by the video frame while the pane draws the shifted one, so pause editing until the offset is applied.
+    const offsetEditLock = computed(() => !readonlyState.value
+      && Object.keys(pendingAnnotationShifts.value).length > 0);
+    // Saving still follows readonlyState alone: applying an offset saves pending edits first.
+    const editLocked = computed(() => readonlyState.value || offsetEditLock.value);
     // Serialized shape of the currently installed timeline. The computed
     // re-evaluates whenever any camera's imageData array identity changes --
     // including pure display-URL swaps (e.g. the percentile-stretch remap)
@@ -625,7 +679,6 @@ export default defineComponent({
      * loadData resolves), but watches, aligned navigation, and metadata
      * hydration only run for multicamera datasets.
      */
-    const cameraRegistration = new CameraRegistrationStore();
     const alignedView = new AlignedViewStore();
     const referenceCamera = computed(() => {
       const cams = multiCamList.value;
@@ -805,17 +858,7 @@ export default defineComponent({
     const autoRegisterJob = createAutoRegisterJobService({
       datasetId,
       cameras: multiCamList,
-      frameCount: (camera: string) => {
-        const images = imageData.value[camera];
-        if (images && images.length) {
-          return images.length;
-        }
-        try {
-          return aggregateController.value.getController(camera).maxFrame.value + 1;
-        } catch {
-          return 0;
-        }
-      },
+      frameCount: cameraFrameCount,
       timestampsFor: (camera: string) => {
         const images = imageData.value[camera];
         if (!images || !images.length
@@ -907,7 +950,7 @@ export default defineComponent({
       groupFilterControls: groupFilters,
       cameraStore,
       aggregateController,
-      readonlyState,
+      readonlyState: editLocked,
       alignedView,
       isStereoscopicDataset: computed(() => subType.value === 'stereo'),
       lassoModeActive: lassoMode.lassoModeActive,
@@ -1002,11 +1045,31 @@ export default defineComponent({
       return multiSelectList.value;
     });
 
+    // Under an aligned timeline each camera's stored frames differ from the playhead's slots.
+    const trackReplicas = (id: AnnotationId): [string, Track][] => {
+      const replicas: [string, Track][] = [];
+      cameraStore.camMap.value.forEach(({ trackStore }, camera) => {
+        const track = trackStore.getPossible(id);
+        if (track) replicas.push([camera, track]);
+      });
+      return replicas;
+    };
+    const cameraFrameToSlot = (camera: string, frame: number) => (
+      aggregateController.value.cameraFrameToSlot(camera, frame)
+    );
+    const onTimeline = {
+      timelineRange: (id: AnnotationId) => (alignedTimeline.value.aligned
+        ? timelineRange(trackReplicas(id), cameraFrameToSlot) : null),
+      timelineFeatures: (id: AnnotationId) => (alignedTimeline.value.aligned
+        ? timelineFeatures(trackReplicas(id), cameraFrameToSlot) : null),
+    };
+
     const { lineChartData } = useLineChart({
       enabledTracks: trackFilters.enabledAnnotations,
       typeStyling: trackStyleManager.typeStyling,
       allTypes: trackFilters.allTypes,
       getTrackProjection,
+      ...onTimeline,
     });
 
     const { eventChartData } = useEventChart({
@@ -1014,6 +1077,7 @@ export default defineComponent({
       selectedTrackIds: allSelectedIds,
       typeStyling: trackStyleManager.typeStyling,
       getTrackProjection,
+      ...onTimeline,
     });
 
     const { eventChartData: groupChartData } = useEventChart({
@@ -1511,6 +1575,8 @@ export default defineComponent({
         cameraCorrespondences: cameraRegistration.observations.value,
         cameraTransformTypes: cameraRegistration.transformTypes.value,
         cameraRegistrationSource: cameraRegistration.source.value,
+        cameraFrameOffsets: cameraRegistration.frameOffsets.value,
+        cameraFrameOffsetsApplied: cameraRegistration.appliedFrameOffsets.value,
       });
       cameraRegistration.markSaved();
     }
@@ -1737,6 +1803,8 @@ export default defineComponent({
       emit('change-camera', camera);
     };
     /** Trigger data load */
+    /** Let the browser paint and run other tasks between batches of track inserts. */
+    const yieldToBrowser = () => new Promise((resolve) => { window.setTimeout(resolve, 0); });
     const loadData = async () => {
       annotationUndo.reset();
       try {
@@ -1899,14 +1967,31 @@ export default defineComponent({
         imageData.value = Object.fromEntries(
           multiCamList.value.map((camera) => [camera, [] as FrameImage[]]),
         );
-        for (let i = 0; i < multiCamList.value.length; i += 1) {
-          const camera = multiCamList.value[i];
-          let cameraId = baseMulticamDatasetId.value;
-          if (multiCamList.value.length > 1) {
-            cameraId = `${baseMulticamDatasetId.value}/${camera}`;
+        // Configs are small, so every camera's is fetched at once; annotations are the heavy
+        // server work, so they load one camera at a time to keep each open's peak load as on main.
+        const cameraIds = multiCamList.value.map((camera) => (multiCamList.value.length > 1
+          ? `${datasetId.value}/${camera}`
+          : datasetId.value));
+        const detectionsInOrder = (async () => {
+          const loaded: Awaited<ReturnType<typeof loadDetections>>[] = [];
+          for (let i = 0; i < cameraIds.length; i += 1) {
+            // eslint-disable-next-line no-await-in-loop
+            loaded.push(await loadDetections(cameraIds[i], props.revision, props.currentSet));
           }
-          // eslint-disable-next-line no-await-in-loop
-          const subCameraMeta = await loadConfig(cameraId);
+          return loaded;
+        })();
+        const [configs, detectionsByCamera] = await Promise.all([
+          Promise.all(cameraIds.map((cameraId) => loadConfig(cameraId))),
+          detectionsInOrder,
+        ]);
+        const cameraLoads = multiCamList.value.map((camera, i) => ({
+          camera,
+          cameraId: cameraIds[i],
+          subCameraMeta: configs[i],
+          detections: detectionsByCamera[i],
+        }));
+        for (let i = 0; i < cameraLoads.length; i += 1) {
+          const { camera, subCameraMeta } = cameraLoads[i];
           VueSet(cameraTypesByCamera.value, camera, subCameraMeta.type as DatasetType);
           if (multiCamList.value.length <= 1) {
             datasetType.value = subCameraMeta.type as DatasetType;
@@ -1931,12 +2016,13 @@ export default defineComponent({
           }
           cameraStore.addCamera(camera);
           addSaveCamera(camera);
-          const {
-            tracks,
-            groups,
-            sets: foundSets,
-            // eslint-disable-next-line no-await-in-loop
-          } = await loadDetections(cameraId, props.revision, props.currentSet);
+        }
+        // Media is known for every camera: mount the panes now so the videos
+        // fetch their metadata while the annotations are still being inserted.
+        progress.mediaLoaded = true;
+        for (let i = 0; i < cameraLoads.length; i += 1) {
+          const { camera, cameraId, detections } = cameraLoads[i];
+          const { tracks, groups, sets: foundSets } = detections;
           sets.value = foundSets.filter((item) => item);
           if (props.currentSet !== '' || sets.value.length > 0) {
             sets.value.push('default');
@@ -1961,7 +2047,7 @@ export default defineComponent({
               /* Every N tracks, yeild some cycles for other scheduled tasks */
                 progress.progress = j;
                 // eslint-disable-next-line no-await-in-loop
-                await new Promise((resolve) => window.setTimeout(resolve, 500));
+                await yieldToBrowser();
               }
               trackStore.insert(Track.fromJSON(tracks[j], baseSet), { imported: true });
             }
@@ -1970,7 +2056,7 @@ export default defineComponent({
               /* Every N tracks, yeild some cycles for other scheduled tasks */
                 progress.progress = tracks.length + j;
                 // eslint-disable-next-line no-await-in-loop
-                await new Promise((resolve) => window.setTimeout(resolve, 500));
+                await yieldToBrowser();
               }
               groupStore.insert(Group.fromJSON(groups[j]), { imported: true });
             }
@@ -1998,7 +2084,7 @@ export default defineComponent({
                     /* Every N tracks, yeild some cycles for other scheduled tasks */
                     progress.progress = j;
                     // eslint-disable-next-line no-await-in-loop
-                    await new Promise((resolve) => window.setTimeout(resolve, 500));
+                    await yieldToBrowser();
                   }
                   // We need to increment the trackIds for the new comparison sets
                   setTracks[j].id = trackStore.getNewId();
@@ -2054,6 +2140,8 @@ export default defineComponent({
             meta.cameraCorrespondences,
             meta.cameraTransformTypes,
             meta.cameraRegistrationSource,
+            meta.cameraFrameOffsets,
+            meta.cameraFrameOffsetsApplied,
           );
           // Media is loaded at this point: resolve observation frames from
           // their image names against this dataset's own frame ordering.
@@ -2150,6 +2238,7 @@ export default defineComponent({
         }
       } catch (err) {
         progress.loaded = false;
+        progress.mediaLoaded = false;
         console.error(err);
         const errorEl = document.createElement('div');
         errorEl.innerHTML = getResponseError(err);
@@ -2192,6 +2281,7 @@ export default defineComponent({
 
     const reloadAnnotations = async () => {
       progress.loaded = false;
+      progress.mediaLoaded = false;
       discardChanges();
       Object.values(debouncedSaves).forEach((fn) => fn.cancel());
       Object.keys(debouncedSaves).forEach((k) => delete debouncedSaves[k]);
@@ -2211,8 +2301,41 @@ export default defineComponent({
         ? props.comparisonSets.slice(0, 1) : props.comparisonSets;
     };
 
+    /**
+     * Replace one camera's in-memory annotations with what persistence now
+     * holds, e.g. after the server shifted them onto a time offset. Same
+     * bulk-insert path as loadData, so a large camera reloads without
+     * blocking the page; a comparison view falls back to a full reload
+     * because its extra sets are only rebuilt there.
+     */
+    const reloadCameraAnnotations = async (camera: string) => {
+      const stores = cameraStore.camMap.value.get(camera);
+      if (!stores || props.comparisonSets.length) {
+        await reloadAnnotations();
+        return;
+      }
+      handler.trackSelect(null, false);
+      const parentId = baseMulticamDatasetId.value ?? datasetId.value;
+      const cameraId = multiCamList.value.length > 1 ? `${parentId}/${camera}` : parentId;
+      const { tracks, groups } = await loadDetections(cameraId, props.revision, props.currentSet);
+      stores.trackStore.clearAll();
+      stores.groupStore.clearAll();
+      for (let j = 0; j < tracks.length; j += 1) {
+        if (j % 4000 === 0 && j > 0) {
+          // eslint-disable-next-line no-await-in-loop
+          await yieldToBrowser();
+        }
+        stores.trackStore.insert(Track.fromJSON(tracks[j]), { imported: true });
+      }
+      groups.forEach((group) => {
+        stores.groupStore.insert(Group.fromJSON(group), { imported: true });
+      });
+      // Undo snapshots predate the reload, so restoring one would write stale frames back.
+      annotationUndo.start();
+    };
+
     watch(datasetId, reloadAnnotations);
-    watch(readonlyState, () => handler.trackSelect(null, false));
+    watch(editLocked, () => handler.trackSelect(null, false));
     // Update segmentation recipe when frame changes to show only current frame's points
     watch(() => time.frame.value, (newFrame) => {
       segmentationRecipe.handleFrameChange(newFrame);
@@ -2258,6 +2381,7 @@ export default defineComponent({
       setAttribute,
       deleteAttribute,
       reloadAnnotations,
+      reloadCameraAnnotations,
       setSVGFilters,
       selectCamera,
       linkCameraTrack,
@@ -2308,7 +2432,12 @@ export default defineComponent({
         trackFilters,
         trackStyleManager,
         visibleModes,
-        readOnlyMode: readonlyState,
+        readOnlyMode: editLocked,
+        offsetEditLock,
+        trackTimeline: {
+          range: onTimeline.timelineRange,
+          seekSlot: (slot: number) => aggregateController.value.seek(slot),
+        },
         imageEnhancements,
         percentileStretchSupported,
         percentileHistogram,
@@ -2567,6 +2696,7 @@ export default defineComponent({
       context,
       readonlyState,
       linkingState,
+      editLocked,
       cameraEnhOutputs,
       isCameraDefault,
       cameraPercentileStretch,
@@ -2772,7 +2902,7 @@ export default defineComponent({
         <EditorMenu
           ref="editorMenuRef"
           :has-selected-track="selectedTrackId !== null"
-          :disabled="readonlyState || linkingState || !progress.loaded"
+          :disabled="editLocked || linkingState || !progress.loaded"
           v-bind="{
             editingMode,
             visibleModes,
@@ -2781,8 +2911,8 @@ export default defineComponent({
             multiSelectActive,
             editingDetails,
             groupEditActive: editingGroupId !== null,
-            lassoModeActive: !readonlyState && lassoModeActive,
-            lassoDrawing: !readonlyState && lassoDrawing,
+            lassoModeActive: !editLocked && lassoModeActive,
+            lassoDrawing: !editLocked && lassoDrawing,
             textQueryEnabled,
             textQueryAvailable,
             checkTextQueryAvailable,
@@ -2971,12 +3101,12 @@ export default defineComponent({
       >
         <div
           v-if="progress.loaded"
-          v-mousetrap="[
-            { bind: 'n', handler: () => !readonlyState && handler.trackAdd() },
+          v-mousetrap="progress.loaded ? [
+            { bind: 'n', handler: () => !editLocked && handler.trackAdd() },
             { bind: 'r', handler: () => resetAggregateZoom() },
             { bind: 'esc', handler: () => handler.trackAbort() },
             { bind: 'e', handler: () => multiCamList.length === 1 && selectedTrackId !== null && handler.trackEdit(selectedTrackId) },
-          ]"
+          ] : []"
           class="d-flex flex-column grow"
         >
           <div class="d-flex grow">
@@ -3031,7 +3161,7 @@ export default defineComponent({
           />
         </div>
         <div
-          v-else
+          v-if="!progress.loaded"
           class="d-flex justify-center align-center fill-height"
         >
           <v-alert
@@ -3074,13 +3204,13 @@ export default defineComponent({
       <div class="d-flex grow" style="min-height: 0;">
         <div
           v-if="progress.loaded"
-          v-mousetrap="[
-            { bind: 'n', handler: () => !readonlyState && handler.trackAdd() },
+          v-mousetrap="progress.loaded ? [
+            { bind: 'n', handler: () => !editLocked && handler.trackAdd() },
             { bind: 'r', handler: () => resetAggregateZoom() },
             { bind: 'esc', handler: () => handler.trackAbort() },
             { bind: 'e', handler: () => multiCamList.length === 1 && selectedTrackId !== null && handler.trackEdit(selectedTrackId) },
             { bind: 'a', handler: () => sidebarMode === 'bottom' && toggleBottomRightPanel() },
-          ]"
+          ] : []"
           class="d-flex flex-column grow"
           style="min-height: 0; min-width: 0;"
         >
@@ -3135,7 +3265,7 @@ export default defineComponent({
             :track-filters="trackFilters"
             :attributes="attributes"
             :frame-rate="frameRate"
-            :readonly-state="readonlyState"
+            :readonly-state="editLocked"
             :disable-annotation-filters="disableAnnotationFilters"
             :prompt-visible="visible"
             :confidence-filters="confidenceFilters"
@@ -3155,7 +3285,7 @@ export default defineComponent({
           />
         </div>
         <div
-          v-else
+          v-if="!progress.loaded"
           class="d-flex justify-center align-center fill-height grow"
           style="min-width: 0;"
         >
@@ -3209,6 +3339,14 @@ export default defineComponent({
 </template>
 
 <style lang="scss">
+.load-progress-overlay {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  z-index: 5;
+  pointer-events: none;
+}
 html {
   overflow-y: auto;
  scrollbar-face-color: #646464;
diff --git a/client/dive-common/frameOffsetAnnotations.spec.ts b/client/dive-common/frameOffsetAnnotations.spec.ts
new file mode 100644
index 000000000..525e152a9
--- /dev/null
+++ b/client/dive-common/frameOffsetAnnotations.spec.ts
@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest';
+import type { TrackData } from 'vue-media-annotator/track';
+import type { GroupData } from 'vue-media-annotator/Group';
+import {
+  pendingFrameShifts, shiftAnnotationRecords, shiftGroupData, shiftTrackData,
+} from './frameOffsetAnnotations';
+
+function track(frames: number[], id = 1): TrackData {
+  return {
+    id,
+    attributes: {},
+    confidencePairs: [['fish', 1]],
+    begin: Math.min(...frames),
+    end: Math.max(...frames),
+    features: frames.map((frame) => ({ frame, bounds: [0, 0, 1, 1] })),
+  };
+}
+
+function group(members: GroupData['members'], id = 1): GroupData {
+  const ranges = Object.values(members).flatMap((m) => m.ranges);
+  return {
+    id,
+    attributes: {},
+    confidencePairs: [['school', 1]],
+    begin: Math.min(...ranges.map(([b]) => b)),
+    end: Math.max(...ranges.map(([, e]) => e)),
+    members,
+  };
+}
+
+describe('shiftTrackData', () => {
+  it('moves every feature and the bounds by the delta', () => {
+    const shifted = shiftTrackData(track([3, 4, 5]), 9);
+    expect(shifted?.begin).toBe(12);
+    expect(shifted?.end).toBe(14);
+    expect(shifted?.features.map((f) => f.frame)).toStrictEqual([12, 13, 14]);
+  });
+
+  it('drops features that would land before frame 0', () => {
+    const shifted = shiftTrackData(track([3, 4, 5]), -4);
+    expect(shifted?.features.map((f) => f.frame)).toStrictEqual([0, 1]);
+    expect(shifted?.begin).toBe(0);
+    expect(shifted?.end).toBe(1);
+  });
+
+  it('rebounds to the first surviving feature across a gap', () => {
+    const shifted = shiftTrackData(track([3, 10]), -5);
+    expect(shifted?.features.map((f) => f.frame)).toStrictEqual([5]);
+    expect(shifted?.begin).toBe(5);
+    expect(shifted?.end).toBe(5);
+  });
+
+  it('returns null when nothing survives', () => {
+    expect(shiftTrackData(track([0, 1]), -5)).toBeNull();
+  });
+
+  it('is the identity at delta 0', () => {
+    const data = track([1]);
+    expect(shiftTrackData(data, 0)).toBe(data);
+  });
+});
+
+describe('shiftGroupData', () => {
+  it('moves and clips member ranges, dropping emptied members', () => {
+    const shifted = shiftGroupData(group({
+      1: { ranges: [[2, 6], [10, 20]] },
+      2: { ranges: [[0, 1]] },
+    }), -4);
+    expect(shifted?.members).toStrictEqual({ 1: { ranges: [[0, 2], [6, 16]] } });
+    expect(shifted?.begin).toBe(0);
+    expect(shifted?.end).toBe(16);
+  });
+
+  it('returns null when no member survives', () => {
+    expect(shiftGroupData(group({ 1: { ranges: [[0, 1]] } }), -2)).toBeNull();
+  });
+});
+
+describe('shiftAnnotationRecords', () => {
+  it('shifts a keyed annotation file and counts what fell off', () => {
+    const result = shiftAnnotationRecords(
+      { 1: track([3, 4], 1), 2: track([0], 2) },
+      { 1: group({ 2: { ranges: [[0, 0]] } }) },
+      -2,
+    );
+    expect(Object.keys(result.tracks)).toStrictEqual(['1']);
+    expect(result.tracks[1].begin).toBe(1);
+    expect(result.groups).toStrictEqual({});
+    expect(result.dropped).toBe(2);
+  });
+});
+
+describe('pendingFrameShifts', () => {
+  it('reports only the part of an offset not yet applied', () => {
+    expect(pendingFrameShifts({ IR: 9 }, {}, ['EO', 'IR'])).toStrictEqual({ IR: 9 });
+    expect(pendingFrameShifts({ IR: 9 }, { IR: 9 }, ['EO', 'IR'])).toStrictEqual({});
+    expect(pendingFrameShifts({ IR: 7 }, { IR: 9 }, ['EO', 'IR'])).toStrictEqual({ IR: -2 });
+    expect(pendingFrameShifts({}, { IR: 9 }, ['EO', 'IR'])).toStrictEqual({ IR: -9 });
+  });
+});
diff --git a/client/dive-common/frameOffsetAnnotations.ts b/client/dive-common/frameOffsetAnnotations.ts
new file mode 100644
index 000000000..d5c950233
--- /dev/null
+++ b/client/dive-common/frameOffsetAnnotations.ts
@@ -0,0 +1,107 @@
+import type { TrackData } from 'vue-media-annotator/track';
+import type { GroupData } from 'vue-media-annotator/Group';
+
+/**
+ * Shift every frame of a serialized track by `delta`, dropping features that
+ * would land before frame 0. begin/end follow the surviving features, which
+ * is what the server's Track validator requires. Returns null when nothing
+ * survives.
+ */
+export function shiftTrackData(track: TrackData, delta: number): TrackData | null {
+  if (delta === 0) {
+    return track;
+  }
+  const features = track.features
+    .filter((feature) => feature && feature.frame + delta >= 0)
+    .map((feature) => ({ ...feature, frame: feature.frame + delta }));
+  if (!features.length) {
+    return null;
+  }
+  return {
+    ...track,
+    features,
+    begin: features[0].frame,
+    end: features[features.length - 1].frame,
+  };
+}
+
+/**
+ * Shift every member range of a serialized group by `delta`. Ranges ending
+ * before frame 0 are dropped, ranges straddling it are clipped, and members
+ * left with no range are removed. Returns null when no member survives.
+ */
+export function shiftGroupData(group: GroupData, delta: number): GroupData | null {
+  if (delta === 0) {
+    return group;
+  }
+  const members: GroupData['members'] = {};
+  Object.entries(group.members).forEach(([memberId, member]) => {
+    const ranges = member.ranges
+      .filter(([, end]) => end + delta >= 0)
+      .map(([begin, end]) => [Math.max(0, begin + delta), end + delta] as [number, number]);
+    if (ranges.length) {
+      members[Number(memberId)] = { ...member, ranges };
+    }
+  });
+  const allRanges = Object.values(members).flatMap((member) => member.ranges);
+  if (!allRanges.length) {
+    return null;
+  }
+  return {
+    ...group,
+    members,
+    begin: Math.min(...allRanges.map(([begin]) => begin)),
+    end: Math.max(...allRanges.map(([, end]) => end)),
+  };
+}
+
+/**
+ * Shift a whole annotation file's tracks and groups by `delta`, keyed by id
+ * as the desktop track file stores them. `dropped` counts annotations that
+ * had nothing left after the shift.
+ */
+export function shiftAnnotationRecords<T extends TrackData, G extends GroupData>(
+  tracks: Record<string, T>,
+  groups: Record<string, G>,
+  delta: number,
+): { tracks: Record<string, T>; groups: Record<string, G>; dropped: number } {
+  let dropped = 0;
+  const shiftedTracks: Record<string, T> = {};
+  Object.entries(tracks).forEach(([id, track]) => {
+    const shifted = shiftTrackData(track, delta) as T | null;
+    if (shifted === null) {
+      dropped += 1;
+    } else {
+      shiftedTracks[id] = shifted;
+    }
+  });
+  const shiftedGroups: Record<string, G> = {};
+  Object.entries(groups).forEach(([id, group]) => {
+    const shifted = shiftGroupData(group, delta) as G | null;
+    if (shifted === null) {
+      dropped += 1;
+    } else {
+      shiftedGroups[id] = shifted;
+    }
+  });
+  return { tracks: shiftedTracks, groups: shiftedGroups, dropped };
+}
+
+/**
+ * Frames each camera's annotations still need to move: its stored time
+ * offset minus what was already applied to them. Cameras in step are absent.
+ */
+export function pendingFrameShifts(
+  offsets: Record<string, number>,
+  applied: Record<string, number>,
+  cameras: string[],
+): Record<string, number> {
+  const shifts: Record<string, number> = {};
+  cameras.forEach((camera) => {
+    const delta = (offsets[camera] ?? 0) - (applied[camera] ?? 0);
+    if (delta !== 0) {
+      shifts[camera] = delta;
+    }
+  });
+  return shifts;
+}
diff --git a/client/dive-common/timelineTrack.spec.ts b/client/dive-common/timelineTrack.spec.ts
new file mode 100644
index 000000000..bc8b7d35c
--- /dev/null
+++ b/client/dive-common/timelineTrack.spec.ts
@@ -0,0 +1,56 @@
+import Track from 'vue-media-annotator/track';
+import { buildInverseAlignedIndex, buildOffsetTimeline } from './alignedTimeline';
+import { timelineFeatures, timelineRange } from './timelineTrack';
+
+function makeTrack(frames: number[], keyframes = frames) {
+  const features: ConstructorParameters<typeof Track>[1]['features'] = [];
+  frames.forEach((frame) => {
+    const keyframe = keyframes.includes(frame);
+    features[frame] = keyframe ? { frame, bounds: [0, 0, 10, 10], keyframe } : { frame, keyframe };
+  });
+  return new Track(1, {
+    begin: Math.min(...frames), end: Math.max(...frames), features,
+  });
+}
+
+function offsetToSlot(counts: Record<string, number>, offsets: Record<string, number>) {
+  const timeline = buildOffsetTimeline(counts, offsets);
+  if (!timeline.aligned) throw new Error('expected an aligned timeline');
+  const inverse = buildInverseAlignedIndex(timeline.slots);
+  return (camera: string, frame: number) => inverse[camera]?.get(frame);
+}
+
+describe('timelineTrack', () => {
+  // IR starts one frame later, so EO's local frame f plays at slot f + 1 and IR's at slot f.
+  const toSlot = offsetToSlot({ EO: 10, IR: 10, UV: 10 }, { IR: 1 });
+
+  it('places a track on the slots its frames play at, not its stored frame numbers', () => {
+    const eo = makeTrack([1, 2]);
+    expect(timelineRange([['EO', eo]], toSlot)).toEqual([2, 3]);
+    expect(timelineFeatures([['EO', eo]], toSlot).map((f) => f.frame)).toEqual([2, 3]);
+  });
+
+  it('merges replicas that share an instant into one slot', () => {
+    const eo = makeTrack([1]);
+    const ir = makeTrack([2]);
+    expect(timelineRange([['EO', eo], ['IR', ir]], toSlot)).toEqual([2, 2]);
+    expect(timelineFeatures([['EO', eo], ['IR', ir]], toSlot)).toEqual([
+      { frame: 2, keyframe: true, interpolate: false },
+    ]);
+  });
+
+  it('keeps a slot a keyframe if any camera has a keyframe there', () => {
+    const eo = makeTrack([1, 3], [1]);
+    const ir = makeTrack([4], [4]);
+    expect(timelineFeatures([['EO', eo], ['IR', ir]], toSlot)).toEqual([
+      { frame: 2, keyframe: true, interpolate: false },
+      { frame: 4, keyframe: true, interpolate: false },
+    ]);
+  });
+
+  it('skips frames that fall outside the timeline and returns null when none remain', () => {
+    const none = () => undefined;
+    expect(timelineRange([['EO', makeTrack([1])]], none)).toBeNull();
+    expect(timelineFeatures([['EO', makeTrack([1])]], none)).toEqual([]);
+  });
+});
diff --git a/client/dive-common/timelineTrack.ts b/client/dive-common/timelineTrack.ts
new file mode 100644
index 000000000..7ccef0ed2
--- /dev/null
+++ b/client/dive-common/timelineTrack.ts
@@ -0,0 +1,52 @@
+import type Track from 'vue-media-annotator/track';
+import type { TimelineFeature } from 'vue-media-annotator/use/useEventChart';
+
+/** A camera's local frame on the playback timeline, or undefined when it has no slot. */
+export type CameraFrameToSlot = (camera: string, localFrame: number) => number | undefined;
+
+/**
+ * A track's first and last timeline slot across every camera it appears on.
+ *
+ * Each camera stores its features in its own frame numbering, which differs from
+ * the timeline's slots once cameras are aligned by timestamp or time offset, so a
+ * min/max over the raw frames would place the track on the wrong slots.
+ */
+export function timelineRange(
+  replicas: [string, Track][],
+  toSlot: CameraFrameToSlot,
+): [number, number] | null {
+  let begin = Infinity;
+  let end = -Infinity;
+  replicas.forEach(([camera, track]) => {
+    [track.begin, track.end].forEach((frame) => {
+      const slot = toSlot(camera, frame);
+      if (slot !== undefined) {
+        begin = Math.min(begin, slot);
+        end = Math.max(end, slot);
+      }
+    });
+  });
+  return begin <= end ? [begin, end] : null;
+}
+
+/** Every feature of a track as timeline slots, merged across cameras and sorted. */
+export function timelineFeatures(
+  replicas: [string, Track][],
+  toSlot: CameraFrameToSlot,
+): TimelineFeature[] {
+  const bySlot = new Map<number, TimelineFeature>();
+  replicas.forEach(([camera, track]) => {
+    track.featureIndex.forEach((frame) => {
+      const feature = track.features[frame];
+      const slot = toSlot(camera, frame);
+      if (!feature || slot === undefined) return;
+      const existing = bySlot.get(slot);
+      bySlot.set(slot, {
+        frame: slot,
+        keyframe: Boolean(feature.keyframe) || Boolean(existing?.keyframe),
+        interpolate: Boolean(feature.interpolate) || Boolean(existing?.interpolate),
+      });
+    });
+  });
+  return [...bySlot.values()].sort((a, b) => a.frame - b.frame);
+}
diff --git a/client/dive-common/use/annotationUndo/AnnotationHistory.spec.ts b/client/dive-common/use/annotationUndo/AnnotationHistory.spec.ts
index 1200c1ea1..bdfaac7b7 100644
--- a/client/dive-common/use/annotationUndo/AnnotationHistory.spec.ts
+++ b/client/dive-common/use/annotationUndo/AnnotationHistory.spec.ts
@@ -166,6 +166,27 @@ it('clears history and queued checkpoints when annotations are reloaded', async
   expect(h.store.annotationIds.value).toEqual([20]);
 });
 
+it('undoes an edit made after a camera reload to the reloaded state, not the pre-reload one', async () => {
+  const h = harness(); const track = h.add(); h.history.start();
+  track.setType('shark', 1);
+  await Promise.resolve();
+  h.store.clearAll();
+  const features: ConstructorParameters<typeof Track>[1]['features'] = [];
+  features[5] = { frame: 5, keyframe: true, bounds: [0, 0, 10, 10] };
+  const shifted = new Track(1, {
+    begin: 5, end: 5, confidencePairs: [['shark', 1]], features,
+  });
+  h.store.insert(shifted, { imported: true });
+  h.history.start();
+  shifted.setType('ray', 1);
+  await Promise.resolve();
+  expect(h.history.undo()).toBe(true);
+  const restored = h.store.get(1);
+  expect(restored.begin).toBe(5);
+  expect(restored.getType()[0]).toBe('shark');
+  expect(h.history.undo()).toBe(false);
+});
+
 it('releases the async undo lock on failure and can undo any partial changes', async () => {
   const h = harness(); const track = h.add(); h.history.start();
   await expect(h.history.run(async () => {
diff --git a/client/dive-common/use/useAutoRegisterJob.ts b/client/dive-common/use/useAutoRegisterJob.ts
index e3b4f091e..e6248edd1 100644
--- a/client/dive-common/use/useAutoRegisterJob.ts
+++ b/client/dive-common/use/useAutoRegisterJob.ts
@@ -241,6 +241,7 @@ export function createAutoRegisterJobService(deps: AutoRegisterJobDeps): AutoReg
       meta.cameraCorrespondences,
       meta.cameraTransformTypes,
       meta.cameraRegistrationSource,
+      meta.cameraFrameOffsets,
     );
     if (priorPair) {
       registration.setActivePair(priorPair.camA, priorPair.camB);
diff --git a/client/platform/desktop/backend/native/cameraRegistration.spec.ts b/client/platform/desktop/backend/native/cameraRegistration.spec.ts
index 2e589e790..986488b41 100644
--- a/client/platform/desktop/backend/native/cameraRegistration.spec.ts
+++ b/client/platform/desktop/backend/native/cameraRegistration.spec.ts
@@ -133,13 +133,13 @@ describe('buildRegistrationPipelineArgs', () => {
     const uvPath = npath.join(jobWorkDir, 'uv_to_rgb_registration.json');
     expect(args).toStrictEqual({
       'warp2:transformation_file': uvPath,
-      'warp2:transform_reader:type': 'dive',
-      'warp2:transform_reader:dive:from_camera': 'uv',
-      'warp2:transform_reader:dive:to_camera': 'rgb',
+      'warp2:transform_reader:type': 'homography_json',
+      'warp2:transform_reader:homography_json:from_camera': 'uv',
+      'warp2:transform_reader:homography_json:to_camera': 'rgb',
       'warp3:transformation_file': irPath,
-      'warp3:transform_reader:type': 'dive',
-      'warp3:transform_reader:dive:from_camera': 'ir',
-      'warp3:transform_reader:dive:to_camera': 'rgb',
+      'warp3:transform_reader:type': 'homography_json',
+      'warp3:transform_reader:homography_json:from_camera': 'ir',
+      'warp3:transform_reader:homography_json:to_camera': 'rgb',
     });
     const written = await fs.readJSON(irPath);
     expect(written.type).toBe('dive-camera-registration');
@@ -159,7 +159,7 @@ describe('buildRegistrationPipelineArgs', () => {
     // (no warps declared, so that is not an error); ir (warp3) has a
     // reference pair.
     expect(Object.keys(args).some((key) => key.startsWith('warp2'))).toBe(false);
-    expect(args['warp3:transform_reader:dive:from_camera']).toBe('ir');
+    expect(args['warp3:transform_reader:homography_json:from_camera']).toBe('ir');
     const irPath = npath.join(jobWorkDir, 'ir_to_rgb_registration.json');
     expect(args['warp3:transformation_file']).toBe(irPath);
     // The uv-to-ir pair is dropped from ir's job file too.
@@ -197,7 +197,7 @@ describe('buildRegistrationPipelineArgs', () => {
     const jobWorkDir = '/home/user/job/seeded';
     await fs.ensureDir(jobWorkDir);
     const args = await buildRegistrationPipelineArgs(settings, meta, jobWorkDir, ['rgb', 'ir']);
-    expect(args['warp2:transform_reader:dive:from_camera']).toBe('ir');
-    expect(args['warp2:transform_reader:dive:to_camera']).toBe('rgb');
+    expect(args['warp2:transform_reader:homography_json:from_camera']).toBe('ir');
+    expect(args['warp2:transform_reader:homography_json:to_camera']).toBe('rgb');
   });
 });
diff --git a/client/platform/desktop/backend/native/cameraRegistration.ts b/client/platform/desktop/backend/native/cameraRegistration.ts
index f12c07f30..2fb03c579 100644
--- a/client/platform/desktop/backend/native/cameraRegistration.ts
+++ b/client/platform/desktop/backend/native/cameraRegistration.ts
@@ -279,9 +279,9 @@ export async function buildRegistrationPipelineArgs(
     const registrationPath = npath.join(jobWorkDir, registrationFileName(camera, reference));
     writes.push(writeJsonFile(registrationPath, { ...file.body, pairs: [pair] }));
     args[`warp${input}:transformation_file`] = registrationPath;
-    args[`warp${input}:transform_reader:type`] = 'dive';
-    args[`warp${input}:transform_reader:dive:from_camera`] = camera;
-    args[`warp${input}:transform_reader:dive:to_camera`] = reference;
+    args[`warp${input}:transform_reader:type`] = 'homography_json';
+    args[`warp${input}:transform_reader:homography_json:from_camera`] = camera;
+    args[`warp${input}:transform_reader:homography_json:to_camera`] = reference;
   });
   await Promise.all(writes);
   return args;
diff --git a/client/platform/desktop/backend/native/common.ts b/client/platform/desktop/backend/native/common.ts
index 02d13c896..5250631d8 100644
--- a/client/platform/desktop/backend/native/common.ts
+++ b/client/platform/desktop/backend/native/common.ts
@@ -30,6 +30,7 @@ import {
   PipelineParamType,
   FrameMetadataAttachmentText,
   FrameMetadataSourcesResponse,
+  CameraFrameOffsetResult,
 } from 'dive-common/apispec';
 import { orderedMultiCamCameraNames } from 'dive-common/multicamDisplay';
 import { parseCameraOrderHeader } from 'dive-common/pipelineCameraOrder';
@@ -44,6 +45,7 @@ import type {
   ScoringSource, ScoringSourceOptions,
 } from 'dive-common/scoring/types';
 import { summarizeResult } from 'dive-common/scoring/metrics';
+import { shiftAnnotationRecords } from 'dive-common/frameOffsetAnnotations';
 import * as viameSerializers from 'platform/desktop/backend/serializers/viame';
 import * as nistSerializers from 'platform/desktop/backend/serializers/nist';
 import * as dive from 'platform/desktop/backend/serializers/dive';
@@ -1404,6 +1406,13 @@ async function saveConfig(settings: Settings, datasetId: string, args: DatasetCo
     if (cameraRolesPresent && !cameraName) {
       existing.cameraRoles = args.cameraRoles;
     }
+    // Time offsets describe the rig, so they live on the multicamera parent only.
+    if (args.cameraFrameOffsets && !cameraName) {
+      existing.cameraFrameOffsets = args.cameraFrameOffsets;
+    }
+    if (args.cameraFrameOffsetsApplied && !cameraName) {
+      existing.cameraFrameOffsetsApplied = args.cameraFrameOffsetsApplied;
+    }
 
     // Registration files remain separate so each camera pair has one persisted owner.
     if (args.cameraHomographies || args.cameraCorrespondences || args.cameraTransformTypes
@@ -1421,6 +1430,48 @@ async function saveConfig(settings: Settings, datasetId: string, args: DatasetCo
   }
 }
 
+/**
+ * Bring one camera's stored annotations onto its time offset (the desktop
+ * twin of the server's apply_camera_frame_offset). Only the part not yet
+ * applied moves, and the offset plus its applied record are written together
+ * afterwards, so a failed shift never leaves the record ahead of the data.
+ */
+async function applyCameraFrameOffset(
+  settings: Settings,
+  datasetId: string,
+  camera: string,
+  offset: number,
+): Promise<CameraFrameOffsetResult> {
+  const { parentId, cameraName } = parseCompositeDatasetId(datasetId);
+  if (cameraName) {
+    throw new Error('Time offsets are applied through the multicamera dataset, not a camera');
+  }
+  const projectDirInfo = await getValidatedProjectDir(settings, parentId);
+  const config = await loadJsonConfig(projectDirInfo.datasetFileAbsPath);
+  if (!config.multiCam?.cameras[camera]) {
+    throw new Error(`Unknown camera "${camera}"`);
+  }
+  const delta = offset - (config.cameraFrameOffsetsApplied?.[camera] ?? 0);
+  const counts = { tracks: 0, groups: 0, dropped: 0 };
+  if (delta !== 0) {
+    const cameraId = `${parentId}/${camera}`;
+    const cameraDir = await getValidatedProjectDir(settings, cameraId);
+    const existing = await loadAnnotationFile(cameraDir.trackFileAbsPath);
+    const { tracks, groups, dropped } = shiftAnnotationRecords(existing.tracks, existing.groups, delta);
+    await _saveSerialized(settings, cameraId, { ...existing, tracks, groups });
+    counts.tracks = Object.keys(tracks).length;
+    counts.groups = Object.keys(groups).length;
+    counts.dropped = dropped;
+  }
+  await saveConfig(settings, parentId, {
+    cameraFrameOffsets: { ...config.cameraFrameOffsets, [camera]: offset },
+    cameraFrameOffsetsApplied: { ...config.cameraFrameOffsetsApplied, [camera]: offset },
+  });
+  return {
+    camera, offset, delta, ...counts,
+  };
+}
+
 async function saveAttributes(settings: Settings, datasetId: string, args: SaveAttributeArgs) {
   const projectDirData = await getValidatedProjectDir(settings, datasetId);
   const projectMetaData = await loadJsonConfig(projectDirData.datasetFileAbsPath);
@@ -3130,6 +3181,7 @@ export {
   ingestDataFiles,
   saveDetections,
   saveConfig,
+  applyCameraFrameOffset,
   saveProjectConfig,
   processTrainedPipeline,
   findResumableTrainingJobs,
diff --git a/client/platform/desktop/backend/native/mediaJobs.ts b/client/platform/desktop/backend/native/mediaJobs.ts
index 78ab377d3..aac878f1d 100644
--- a/client/platform/desktop/backend/native/mediaJobs.ts
+++ b/client/platform/desktop/backend/native/mediaJobs.ts
@@ -33,6 +33,8 @@ const VideoArgs = [
    * https://video.stackexchange.com/questions/20871/how-do-i-convert-anamorphic-hdv-video-to-normal-h-264-video-with-ffmpeg-how-to
    */
   '-vf', 'scale=round(iw*sar/2)*2:round(ih/2)*2,setsar=1',
+  // Put the index up front so a browser can start playing before the file is down.
+  '-movflags', '+faststart',
 ];
 
 const ffmpegPath = getBinaryPath('ffmpeg-ffprobe-static/ffmpeg');
diff --git a/client/platform/desktop/backend/native/multiCamFrameOffset.spec.ts b/client/platform/desktop/backend/native/multiCamFrameOffset.spec.ts
new file mode 100644
index 000000000..d31def7fb
--- /dev/null
+++ b/client/platform/desktop/backend/native/multiCamFrameOffset.spec.ts
@@ -0,0 +1,67 @@
+import { pairedStartFrames } from './multiCamUtils';
+
+/**
+ * Pipeline inputs pair positionally -- row i of one camera's list with row i
+ * of every other's -- so a rig whose recorders started at different times
+ * hands a two-camera detector mismatched instants unless the inputs are
+ * aligned first. Nothing downstream reports that; the associations are just
+ * wrong. These cover the arithmetic that prevents it.
+ *
+ * Frame counts arrive already resolved (an image sequence knows its own, a
+ * video is probed), so this works the same for either medium -- which is the
+ * point: an all-video rig is exactly the case that needs it.
+ */
+describe('pairedStartFrames', () => {
+  it('skips the late camera past its unpaired lead', () => {
+    // IR frame 9 is the same instant as EO frame 0.
+    const result = pairedStartFrames({ EO: 100, IR: 100 }, { IR: 9 });
+    expect(result?.start).toStrictEqual({ EO: 0, IR: 9 });
+    // IR runs out 9 frames earlier, so both stop there.
+    expect(result?.length).toBe(91);
+  });
+
+  it('skips the reference instead when the other camera leads', () => {
+    const result = pairedStartFrames({ EO: 100, IR: 100 }, { IR: -4 });
+    expect(result?.start).toStrictEqual({ EO: 4, IR: 0 });
+    expect(result?.length).toBe(96);
+  });
+
+  it('ends where the shortest camera does', () => {
+    const result = pairedStartFrames({ EO: 100, IR: 50 }, { IR: 9 });
+    expect(result?.start).toStrictEqual({ EO: 0, IR: 9 });
+    expect(result?.length).toBe(41);
+  });
+
+  it('bounds a pair of unequal-length videos to their common span', () => {
+    // The case that desynchronized the warp pipeline at teardown: one input
+    // ran on after the other had completed.
+    const result = pairedStartFrames({ EO: 9000, IR: 9008 }, { IR: 9 });
+    expect(result?.start).toStrictEqual({ EO: 0, IR: 9 });
+    // IR contributes 8999 frames from index 9; EO has 9000 from index 0.
+    expect(result?.length).toBe(8999);
+  });
+
+  it('handles three cameras with independent offsets', () => {
+    const result = pairedStartFrames({ EO: 100, IR: 100, UV: 100 }, { IR: 9, UV: -4 });
+    // UV is earliest, so every camera skips forward to UV's first paired slot.
+    expect(result?.start).toStrictEqual({ EO: 4, IR: 13, UV: 0 });
+    expect(result?.length).toBe(87);
+  });
+
+  it('declines when nothing is offset, keeping the untouched path', () => {
+    expect(pairedStartFrames({ EO: 100, IR: 100 }, { EO: 0, IR: 0 })).toBeNull();
+    expect(pairedStartFrames({ EO: 100, IR: 100 }, undefined)).toBeNull();
+  });
+
+  it('reports no paired span when an offset outruns a camera', () => {
+    const result = pairedStartFrames({ EO: 100, IR: 5 }, { IR: 9 });
+    expect(result?.length).toBeLessThanOrEqual(0);
+  });
+
+  it('ignores a camera whose count could not be resolved', () => {
+    // A probe that fails yields 0; that camera must not drag the span to
+    // nothing and abort a run the other cameras could still support.
+    const result = pairedStartFrames({ EO: 100, IR: 0 }, { IR: 9 });
+    expect(result?.length).toBe(100);
+  });
+});
diff --git a/client/platform/desktop/backend/native/multiCamUtils.ts b/client/platform/desktop/backend/native/multiCamUtils.ts
index 2b7830b12..569fe5b1e 100644
--- a/client/platform/desktop/backend/native/multiCamUtils.ts
+++ b/client/platform/desktop/backend/native/multiCamUtils.ts
@@ -14,6 +14,7 @@ import { orderedMultiCamCameraNames } from 'dive-common/multicamDisplay';
 import { getBinaryPath, spawnResult } from './utils';
 
 const ffmpegPath = getBinaryPath('ffmpeg-ffprobe-static/ffmpeg');
+const ffprobePath = getBinaryPath('ffmpeg-ffprobe-static/ffprobe');
 
 /** Frame subset / range inputs for multicam pipeline arg writing. */
 export interface MultiCamRuntimeSubset {
@@ -98,6 +99,63 @@ async function extractVideoFrames(
   return results;
 }
 
+/**
+ * Where each camera must start reading so row i of every camera's input is
+ * the same instant.
+ *
+ * Cameras on a fixed rig can start recording fractions of a second apart
+ * (see the dataset's cameraFrameOffsets and dive-common/alignedTimeline.ts).
+ * Pipeline inputs pair positionally -- row i with row i -- so without this
+ * a two-camera detector is handed mismatched instants and every cross-camera
+ * association it makes is wrong, silently.
+ *
+ * Camera c's local frame `slot + offset[c]` is slot `slot`; the first slot
+ * every camera can cover is the largest -offset. Returns null when nothing
+ * is offset, so an uncorrected dataset takes exactly the previous path.
+ */
+export function pairedStartFrames(
+  frameCounts: Record<string, number>,
+  offsets: Record<string, number> | undefined,
+): { start: Record<string, number>; length: number } | null {
+  const names = Object.keys(frameCounts);
+  if (!offsets || !names.some((name) => (offsets[name] ?? 0) !== 0)) {
+    return null;
+  }
+  const firstSlot = Math.max(...names.map((name) => -(offsets[name] ?? 0)));
+  const start = Object.fromEntries(
+    names.map((name) => [name, firstSlot + (offsets[name] ?? 0)]),
+  );
+  // Every camera must also STOP together, or the trailing frames of the
+  // longest pair against nothing. For video that is not merely wasted work:
+  // one input completing while another still has frames desynchronizes the
+  // pipeline, and a writer takes a 'complete' datum where it expects data.
+  const spans = names
+    .filter((name) => frameCounts[name] > 0)
+    .map((name) => frameCounts[name] - start[name]);
+  return { start, length: spans.length ? Math.min(...spans) : 0 };
+}
+
+/**
+ * Frames in a video, from the container header.
+ *
+ * Deliberately the declared count rather than a decode: counting frames for
+ * real means decoding the whole file, which would add tens of seconds per
+ * camera to every pipeline launch. On intact media the two agree. A damaged
+ * stream can overstate here, leaving the bound slightly generous -- no worse
+ * than the unbounded behaviour this replaces, and one more reason to
+ * re-encode damaged captures before processing them.
+ */
+async function videoFrameCount(videoPath: string): Promise<number> {
+  const result = await spawnResult(ffprobePath, [
+    '-v', 'error', '-select_streams', 'v:0',
+    '-show_entries', 'stream=nb_frames',
+    '-of', 'default=nokey=1:noprint_wrappers=1',
+    videoPath,
+  ]);
+  const parsed = Number.parseInt((result.output ?? '').trim(), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
 /** frame://N pseudo-name to frame number, or null for real image names. */
 function pseudoFrameNumber(entry: string): number | null {
   const match = /^frame:\/\/(\d+)$/.exec(entry);
@@ -226,6 +284,34 @@ async function writeMultiCamStereoPipelineArgs(
       ? cameraOrder.filter((name) => name in cameras)
       : orderedMultiCamCameraNames(meta.multiCam);
     const cameraList = cameraNames.map((name) => [name, cameras[name]] as const);
+    // Videos are probed for a frame count only when an offset is set.
+    const frameCounts: Record<string, number> = {};
+    if (meta.cameraFrameOffsets
+      && cameraList.some(([name]) => (meta.cameraFrameOffsets?.[name] ?? 0) !== 0)) {
+      // eslint-disable-next-line no-restricted-syntax
+      for (const [name, list] of cameraList) {
+        if (list.originalImageFiles.length) {
+          frameCounts[name] = list.originalImageFiles.length;
+        } else if (list.originalVideoFile) {
+          const vidFile = (list.transcodedVideoFile && forceTranscoded) || list.transcodedMisalign
+            ? list.transcodedVideoFile : list.originalVideoFile;
+          frameCounts[name] = await videoFrameCount(
+            npath.join(list.originalBasePath, vidFile),
+          );
+        } else {
+          frameCounts[name] = 0;
+        }
+      }
+    }
+    const startFrames = pairedStartFrames(frameCounts, meta.cameraFrameOffsets);
+    if (startFrames && startFrames.length <= 0) {
+      // Empty input lists would fail deep inside the pipeline; say why here.
+      throw new Error(
+        'The dataset\'s camera time offsets leave no overlapping frames between '
+        + 'cameras, so there is nothing to run. Check the Time Offset in the '
+        + 'Camera Registration panel.',
+      );
+    }
     for (let i = 0; i < cameraList.length; i += 1) {
       const [key, list] = cameraList[i];
       const { originalBasePath } = list;
@@ -260,6 +346,10 @@ async function writeMultiCamStereoPipelineArgs(
               throw new Error(`Image file not found: ${image}`);
             }
           }
+        } else if (startFrames) {
+          // Keep this camera's paired span: from its first paired instant, as long as the shortest.
+          const from = startFrames.start[key];
+          images = images.slice(from, from + startFrames.length);
         } else if (runtime.frameRange) {
           // The single-camera path filters image lists by frameRange;
           // multicam silently ignored it (a pre-existing no-op) -- apply it
@@ -311,6 +401,13 @@ async function writeMultiCamStereoPipelineArgs(
         const vidTypeArg = `input${i + 1}:video_reader:type`;
         const vidType = 'vidl_ffmpeg';
         argFilePair[vidTypeArg] = vidType;
+        if (startFrames) {
+          // vidl_ffmpeg frames are 1-based and stop_after_frame is inclusive.
+          const from = startFrames.start[key];
+          const reader = `input${i + 1}:video_reader:${vidType}`;
+          argFilePair[`${reader}:start_at_frame`] = String(from + 1);
+          argFilePair[`${reader}:stop_after_frame`] = String(from + startFrames.length);
+        }
         const videoFileName = npath.join(originalBasePath, vidFile);
         argFilePair[inputArg] = videoFileName;
         if (i === 0) {
diff --git a/client/platform/desktop/backend/server.ts b/client/platform/desktop/backend/server.ts
index 0137321b5..3980387f4 100644
--- a/client/platform/desktop/backend/server.ts
+++ b/client/platform/desktop/backend/server.ts
@@ -117,6 +117,18 @@ apirouter.post('/dataset/:id{/:camera}/attribute_track_filters', async (req, res
   return null;
 });
 
+/* Shift one camera's annotations onto its time offset */
+apirouter.post('/dataset/:id/camera_frame_offset', async (req, res, next) => {
+  try {
+    const { camera, offset } = req.body as { camera: string; offset: number };
+    const result = await common.applyCameraFrameOffset(settings.get(), req.params.id, camera, offset);
+    res.json(result);
+  } catch (err) {
+    (err as { status?: number }).status = 500;
+    next(err);
+  }
+});
+
 /* SAVE detections */
 apirouter.post('/dataset/:id{/:camera}/detections', async (req, res, next) => {
   try {
diff --git a/client/platform/desktop/frontend/api.ts b/client/platform/desktop/frontend/api.ts
index 74d87a1aa..d763a0a29 100644
--- a/client/platform/desktop/frontend/api.ts
+++ b/client/platform/desktop/frontend/api.ts
@@ -12,6 +12,7 @@ import type {
   PipelineJobResult,
   ScoringDatasetSummary, ScoringJobArgs, ScoringResult, ScoringResultSummary, ScoringSourceOptions,
   VideoSearchIndexStatus, VideoSearchIndexMethod, VideoSearchQueryResponse, VideoSearchIndexInfo,
+  CameraFrameOffsetResult,
 } from 'dive-common/apispec';
 import axios, { AxiosInstance } from 'axios';
 import { watch } from 'vue';
@@ -976,6 +977,15 @@ async function saveConfig(id: string, args: DatasetConfigMutable) {
   return client.post(`dataset/${id}/meta`, args);
 }
 
+async function applyCameraFrameOffset(id: string, camera: string, offset: number) {
+  const client = await getClient();
+  const { data } = await client.post<CameraFrameOffsetResult>(
+    `dataset/${id}/camera_frame_offset`,
+    { camera, offset },
+  );
+  return data;
+}
+
 async function saveDetections(id: string, args: SaveDetectionsArgs) {
   const client = await getClient();
   return client.post(`dataset/${id}/detections`, args);
@@ -1081,6 +1091,7 @@ export {
   loadScoringResult,
   deleteScoringResult,
   saveConfig,
+  applyCameraFrameOffset,
   saveDetections,
   saveAttributes,
   saveAttributeTrackFilters,
diff --git a/client/platform/web-girder/App.vue b/client/platform/web-girder/App.vue
index a2874863c..2bc24d958 100644
--- a/client/platform/web-girder/App.vue
+++ b/client/platform/web-girder/App.vue
@@ -26,6 +26,7 @@ import {
   getTrainingConfigurations,
   runTraining,
   saveConfig,
+  applyCameraFrameOffset,
   loadGlobalStyleSettings,
   saveGlobalStyleSettings,
   saveAttributes,
@@ -105,6 +106,7 @@ export default defineComponent({
       loadFrameMetadata,
       saveDetections: unwrap(saveDetections),
       saveConfig: unwrap(saveConfig),
+      applyCameraFrameOffset: unwrap(applyCameraFrameOffset),
       loadGlobalStyleSettings,
       saveGlobalStyleSettings,
       saveAttributes: unwrap(saveAttributes),
diff --git a/client/platform/web-girder/api/dataset.service.ts b/client/platform/web-girder/api/dataset.service.ts
index c1c4390c1..698b10c3c 100644
--- a/client/platform/web-girder/api/dataset.service.ts
+++ b/client/platform/web-girder/api/dataset.service.ts
@@ -5,7 +5,7 @@ import {
   registrationValuesSummary, filterRegistrationValues, mergeRegistrationValues,
 } from 'vue-media-annotator/alignedView/cameraRegistrationFiles';
 import {
-  DatasetConfigMutable, DatasetType, FrameImage, GlobalStyleSettings,
+  CameraFrameOffsetResult, DatasetConfigMutable, DatasetType, FrameImage, GlobalStyleSettings,
   SaveAttributeArgs, SaveAttributeTrackFilterArgs,
 } from 'dive-common/apispec';
 import {
@@ -261,6 +261,15 @@ async function saveConfig(datasetId: string, config: DatasetConfigMutable) {
   return girderRest.patch(`/dive_dataset/${folderId}`, config);
 }
 
+/** Shift one camera's stored annotations onto its time offset; the server does the work. */
+async function applyCameraFrameOffset(datasetId: string, camera: string, offset: number) {
+  const { folderId } = await resolveDatasetFolderId(datasetId);
+  return girderRest.patch<CameraFrameOffsetResult>(
+    `/dive_dataset/${folderId}/camera_frame_offset`,
+    { camera, offset },
+  );
+}
+
 // Cross-dataset "shared" color/style overrides. Persisted in localStorage,
 // consistent with how the web client already stores user preferences
 // (clientSettings). This scopes shared colors to the current user/browser.
@@ -555,6 +564,7 @@ export {
   saveAttributes,
   saveAttributeTrackFilters,
   saveConfig,
+  applyCameraFrameOffset,
   loadGlobalStyleSettings,
   saveGlobalStyleSettings,
   uploadCalibrationItem,
diff --git a/client/platform/web-girder/multicamRegistrationSeed.ts b/client/platform/web-girder/multicamRegistrationSeed.ts
index 27e3fcebb..57cb4ea03 100644
--- a/client/platform/web-girder/multicamRegistrationSeed.ts
+++ b/client/platform/web-girder/multicamRegistrationSeed.ts
@@ -32,6 +32,7 @@ export async function parseRegistrationSeed(
   const homographies: CameraRegistrationValues['homographies'] = {};
   const observations: CameraRegistrationValues['observations'] = {};
   const transformTypes: CameraRegistrationValues['transformTypes'] = {};
+  const frameOffsets: Record<string, number> = {};
   const stamps: { file: string; source: RegistrationSource | null }[] = [];
   const warnings: string[] = [];
   // eslint-disable-next-line no-restricted-syntax
@@ -58,6 +59,7 @@ export async function parseRegistrationSeed(
     Object.assign(homographies, store.homographies.value);
     Object.assign(observations, store.observations.value);
     Object.assign(transformTypes, store.transformTypes.value);
+    Object.assign(frameOffsets, store.frameOffsets.value);
     stamps.push({ file: file.name, source: store.source.value });
   }
   const seeded = Object.keys(homographies).length || Object.keys(observations).length;
@@ -67,6 +69,7 @@ export async function parseRegistrationSeed(
       observations,
       transformTypes,
       source: mergeRegistrationSources(stamps),
+      ...(Object.keys(frameOffsets).length ? { frameOffsets } : {}),
     } : null,
     warnings,
   };
diff --git a/client/src/alignedView/CameraRegistrationStore.ts b/client/src/alignedView/CameraRegistrationStore.ts
index dd033f80b..fe5466854 100644
--- a/client/src/alignedView/CameraRegistrationStore.ts
+++ b/client/src/alignedView/CameraRegistrationStore.ts
@@ -139,6 +139,15 @@ export interface RegistrationFilePair {
   leftToRight?: Matrix3 | null;
   rightToLeft?: Matrix3 | null;
   transformType?: TransformType;
+  /**
+   * The right camera's constant start offset in its own frames, relative to
+   * the left: right frame `n + frameOffset` is the same instant as left frame
+   * `n`. Carried here so a producer that measured it (see the batch
+   * registration driver) hands it over with the transform, and a reviewer's
+   * correction travels back out on export. Absent means zero -- no producer
+   * before this wrote one.
+   */
+  frameOffset?: number;
 }
 
 /** Portable calibration file: everything needed to restore all pairs. */
@@ -306,6 +315,23 @@ export default class CameraRegistrationStore {
    */
   source: Ref<RegistrationSource | null>;
 
+  /**
+   * Per-camera constant start offset, in that camera's own frames: local
+   * frame `slot + offset` shows the same instant as the reference camera's
+   * `slot` (see dive-common/alignedTimeline.ts's buildOffsetTimeline).
+   *
+   * Lives here, beside the spatial transform, because it is the other half of
+   * "how these two cameras line up" and persists with the same dataset save.
+   * It is deliberately NOT derived from the transform: on a fixed rig the
+   * static background carries the homography fit, so the registration is
+   * insensitive to the temporal offset and cannot be used to recover or
+   * validate it -- only reviewing moving subjects can.
+   */
+  frameOffsets: Ref<Record<string, number>>;
+
+  /** Per-camera frame offset already baked into that camera's annotations. */
+  appliedFrameOffsets: Ref<Record<string, number>>;
+
   /** True when the calibration has unsaved changes since the last save or load. */
   dirty: ComputedRef<boolean>;
 
@@ -337,6 +363,8 @@ export default class CameraRegistrationStore {
     this.recenterRequest = ref(null);
     this.fitError = ref(null);
     this.source = ref(null);
+    this.frameOffsets = ref({});
+    this.appliedFrameOffsets = ref({});
     this.nextId = 1;
     this.nextRecenterId = 1;
     this.homographySources = {};
@@ -352,6 +380,8 @@ export default class CameraRegistrationStore {
       observations: this.observations.value,
       transformTypes: this.transformTypes.value,
       source: this.source.value,
+      frameOffsets: this.frameOffsets.value,
+      appliedFrameOffsets: this.appliedFrameOffsets.value,
     });
   }
 
@@ -360,6 +390,17 @@ export default class CameraRegistrationStore {
     this.savedSnapshot.value = this.registrationSnapshot();
   }
 
+  /**
+   * Record that `camera`'s time offset was persisted and applied, leaving
+   * the rest of the baseline untouched so other unsaved edits stay dirty.
+   */
+  markFrameOffsetSaved(camera: string, offset: number) {
+    const saved = JSON.parse(this.savedSnapshot.value);
+    saved.frameOffsets = { ...saved.frameOffsets, [camera]: offset };
+    saved.appliedFrameOffsets = { ...saved.appliedFrameOffsets, [camera]: offset };
+    this.savedSnapshot.value = JSON.stringify(saved);
+  }
+
   /**
    * The saved-baseline calibration (what the persisted registration -- the
    * per-camera registration files on desktop, the dataset meta on web --
@@ -1202,6 +1243,7 @@ export default class CameraRegistrationStore {
     const observations: CameraObservations = {};
     const homographies: CameraHomographies = {};
     const transformTypes: CameraTransformTypes = {};
+    const frameOffsets: Record<string, number> = {};
     const cameras = new Set<string>();
     file.pairs.forEach((pair, i) => {
       const context = `Pair ${i + 1}`;
@@ -1212,6 +1254,15 @@ export default class CameraRegistrationStore {
       const key = this.pairKey(pair.left, pair.right);
       cameras.add(pair.left);
       cameras.add(pair.right);
+      if (pair.frameOffset !== undefined) {
+        if (!Number.isInteger(pair.frameOffset)) {
+          throw new Error(`${context}: "frameOffset" must be a whole number of frames`);
+        }
+        // Recorded against the left camera, and stored per camera against the
+        // rig reference -- the same thing whenever left is the reference,
+        // which is how producers write these files.
+        frameOffsets[pair.right] = pair.frameOffset;
+      }
       if (pair.transformType !== undefined) {
         if (!TRANSFORM_TYPES.some((t) => t.value === pair.transformType)) {
           throw new Error(
@@ -1244,6 +1295,7 @@ export default class CameraRegistrationStore {
     this.homographies.value = homographies;
     this.transformTypes.value = transformTypes;
     this.source.value = source;
+    this.frameOffsets.value = frameOffsets;
     this.markHomographySources();
     this.renumberPoints();
     this.pendingPoint.value = null;
@@ -1378,11 +1430,15 @@ export default class CameraRegistrationStore {
     observations?: CameraObservations,
     transformTypes?: CameraTransformTypes,
     source?: RegistrationSource | null,
+    frameOffsets?: Record<string, number> | null,
+    appliedFrameOffsets?: Record<string, number> | null,
   ) {
     this.homographies.value = homographies ? { ...homographies } : {};
     this.observations.value = observations ? { ...observations } : {};
     this.transformTypes.value = transformTypes ? { ...transformTypes } : {};
     this.source.value = source ?? null;
+    this.frameOffsets.value = frameOffsets ? { ...frameOffsets } : {};
+    this.appliedFrameOffsets.value = appliedFrameOffsets ? { ...appliedFrameOffsets } : {};
     this.markHomographySources();
     this.activePair.value = null;
     this.pendingPoint.value = null;
diff --git a/client/src/alignedView/cameraRegistrationFiles.spec.ts b/client/src/alignedView/cameraRegistrationFiles.spec.ts
index 82c62e790..05fb1587e 100644
--- a/client/src/alignedView/cameraRegistrationFiles.spec.ts
+++ b/client/src/alignedView/cameraRegistrationFiles.spec.ts
@@ -234,3 +234,54 @@ describe('mergeRegistrationValues', () => {
     });
   });
 });
+
+/**
+ * A fixed rig's recorders can start a fraction of a second apart. That lag
+ * rides with the transform so a producer that measured it hands it over, and
+ * a reviewer's correction travels back out.
+ */
+describe('frame offsets in registration files', () => {
+  it('writes the right camera\'s offset onto its pair', () => {
+    const files = buildPerCameraRegistrationFiles({
+      homographies: {},
+      observations: {},
+      transformTypes: { 'EO::IR': 'homography' },
+      source: null,
+      frameOffsets: { IR: 12 },
+    }, 'EO');
+    expect(files).toHaveLength(1);
+    expect(files[0].body.pairs[0].frameOffset).toBe(12);
+  });
+
+  it('omits the field entirely when a camera is in step', () => {
+    const files = buildPerCameraRegistrationFiles({
+      homographies: {},
+      observations: {},
+      transformTypes: { 'EO::IR': 'homography' },
+      source: null,
+      frameOffsets: { IR: 0 },
+    }, 'EO');
+    expect(files[0].body.pairs[0]).not.toHaveProperty('frameOffset');
+  });
+
+  it('merges per camera, letting a later file win without clearing others', () => {
+    const merged = mergeRegistrationValues(
+      {
+        homographies: {},
+        observations: {},
+        transformTypes: {},
+        source: null,
+        frameOffsets: { IR: 12, UV: -3 },
+      },
+      {
+        homographies: {},
+        observations: {},
+        transformTypes: {},
+        source: null,
+        frameOffsets: { IR: 9 },
+      },
+      'ir_to_eo_registration.json',
+    );
+    expect(merged.frameOffsets).toStrictEqual({ IR: 9, UV: -3 });
+  });
+});
diff --git a/client/src/alignedView/cameraRegistrationFiles.ts b/client/src/alignedView/cameraRegistrationFiles.ts
index 6e00a1c74..f2a1dedd4 100644
--- a/client/src/alignedView/cameraRegistrationFiles.ts
+++ b/client/src/alignedView/cameraRegistrationFiles.ts
@@ -25,6 +25,12 @@ export interface CameraRegistrationValues {
   observations: CameraObservations;
   transformTypes: CameraTransformTypes;
   source: RegistrationSource | null;
+  /**
+   * Per-camera constant start offset in that camera's own frames. Optional:
+   * files written before this existed carry none, and the in-app default is
+   * an empty map (every camera in step).
+   */
+  frameOffsets?: Record<string, number>;
 }
 
 /**
@@ -109,6 +115,12 @@ function toRegistrationFilePairs(values: CameraRegistrationValues): Registration
       leftToRight: homography ? homography.AtoB : null,
       rightToLeft: homography ? homography.BtoA : null,
       transformType: values.transformTypes[key] || DEFAULT_TRANSFORM_TYPE,
+      // Offsets are stored per camera against the rig reference; a pair
+      // carries the right camera's, which is what "right relative to left"
+      // means whenever the left side IS the reference (the normal case).
+      ...(values.frameOffsets?.[right]
+        ? { frameOffset: values.frameOffsets[right] }
+        : {}),
     };
   });
 }
@@ -291,7 +303,15 @@ export function mergeRegistrationValues(
       files: { previous: existing.source, [incomingLabel]: incoming.source },
     };
   }
+  // Later files win a camera's offset, matching how pairs merge above. An
+  // incoming file that carries none leaves any existing value alone rather
+  // than resetting it to zero.
+  const frameOffsets = { ...existing.frameOffsets, ...incoming.frameOffsets };
   return {
-    homographies, observations, transformTypes, source,
+    homographies,
+    observations,
+    transformTypes,
+    source,
+    ...(Object.keys(frameOffsets).length ? { frameOffsets } : {}),
   };
 }
diff --git a/client/src/components/LayerManager.spec.ts b/client/src/components/LayerManager.spec.ts
index dd5d3700c..f20a61d76 100644
--- a/client/src/components/LayerManager.spec.ts
+++ b/client/src/components/LayerManager.spec.ts
@@ -165,6 +165,7 @@ describe('LayerManager hierarchy frame data', () => {
     };
     const annotator = {
       frame: ref(0),
+      annotationFrame: ref(0),
       flick: ref(0),
       hasFrame: ref(true),
       imageRevision: ref(0),
@@ -283,6 +284,7 @@ function renderCamera(
 ) {
   const annotator = {
     frame: ref(0),
+    annotationFrame: ref(0),
     flick: ref(0),
     hasFrame: ref(true),
     imageRevision: ref(0),
diff --git a/client/src/components/LayerManager.vue b/client/src/components/LayerManager.vue
index c56b57b5f..c94887607 100644
--- a/client/src/components/LayerManager.vue
+++ b/client/src/components/LayerManager.vue
@@ -131,7 +131,7 @@ export default defineComponent({
 
     const aggregateController = injectAggregateController();
     const annotator = aggregateController.value.getController(props.camera);
-    const frameNumberRef = annotator.frame;
+    const frameNumberRef = annotator.annotationFrame;
     const flickNumberRef = annotator.flick;
     const hasFrameRef = annotator.hasFrame;
 
diff --git a/client/src/components/Tracks/TrackItem.spec.ts b/client/src/components/Tracks/TrackItem.spec.ts
new file mode 100644
index 000000000..14f633f41
--- /dev/null
+++ b/client/src/components/Tracks/TrackItem.spec.ts
@@ -0,0 +1,73 @@
+import { defineComponent, h, ref } from 'vue';
+import { shallowMount } from '@vue/test-utils';
+import Track from '../../track';
+import TrackItem from './TrackItem.vue';
+
+const state = vi.hoisted(() => ({
+  range: null as [number, number] | null,
+  seekSlot: vi.fn(),
+}));
+
+vi.mock('../../use/useVuetify', () => ({
+  default: () => ({ theme: { themes: { dark: { accentBackground: '#000' } } } }),
+}));
+
+vi.mock('../../provides', () => ({
+  useTime: () => ({ frame: ref(0) }),
+  useCameraStore: () => ({}),
+  useSelectedCamera: () => ref('EO'),
+  useTrackTimeline: () => ({ range: () => state.range, seekSlot: state.seekSlot }),
+}));
+
+function mountItem() {
+  const features: ConstructorParameters<typeof Track>[1]['features'] = [];
+  features[2] = { frame: 2, bounds: [0, 0, 1, 1], keyframe: true };
+  features[3] = { frame: 3, bounds: [0, 0, 1, 1], keyframe: true };
+  const track = new Track(1, {
+    begin: 2, end: 3, confidencePairs: [['fish', 0.9]], features,
+  });
+  const onSeek = vi.fn();
+  const Host = defineComponent({
+    setup: () => () => h(TrackItem, {
+      props: {
+        compact: true,
+        trackType: 'fish',
+        displayPairIndex: 0,
+        track,
+        inputValue: true,
+        selected: false,
+        secondarySelected: false,
+        editing: false,
+        color: '#fff',
+      },
+      on: { seek: onSeek },
+    }),
+  });
+  const wrapper = shallowMount(Host, { stubs: { TrackItem: false } });
+  return { row: wrapper.findComponent({ name: 'BottomBarTrackItemView' }), onSeek };
+}
+
+beforeEach(() => {
+  state.range = null;
+  state.seekSlot.mockReset();
+});
+
+it('shows and seeks to timeline slots when the track sits on an aligned timeline', () => {
+  state.range = [1, 2];
+  const { row, onSeek } = mountItem();
+  expect(row.props('displayBegin')).toBe(1);
+  expect(row.props('displayEnd')).toBe(2);
+  (row.props('seekBegin') as () => void)();
+  (row.props('seekEnd') as () => void)();
+  expect(state.seekSlot.mock.calls).toEqual([[1], [2]]);
+  expect(onSeek).not.toHaveBeenCalled();
+});
+
+it('shows and seeks to stored frames without an aligned timeline', () => {
+  const { row, onSeek } = mountItem();
+  expect(row.props('displayBegin')).toBe(2);
+  expect(row.props('displayEnd')).toBe(3);
+  (row.props('seekBegin') as () => void)();
+  expect(onSeek).toHaveBeenCalledWith(2);
+  expect(state.seekSlot).not.toHaveBeenCalled();
+});
diff --git a/client/src/components/Tracks/TrackItem.vue b/client/src/components/Tracks/TrackItem.vue
index 5b4c9f9eb..8bf54cb5d 100644
--- a/client/src/components/Tracks/TrackItem.vue
+++ b/client/src/components/Tracks/TrackItem.vue
@@ -5,7 +5,9 @@ import {
 import { ColumnVisibilitySettings } from 'dive-common/store/settings';
 import SideBarTrackItemView from './sidebar/SideBarTrackItemView.vue';
 import BottomBarTrackItemView from './bottombar/BottomBarTrackItemView.vue';
-import { useCameraStore, useSelectedCamera, useTime } from '../../provides';
+import {
+  useCameraStore, useSelectedCamera, useTime, useTrackTimeline,
+} from '../../provides';
 import type { TrackProjection } from '../../TrackProjection';
 import useVuetify from '../../use/useVuetify';
 
@@ -82,6 +84,19 @@ export default defineComponent({
     const { frame: frameRef } = useTime();
     const cameraStore = useCameraStore();
     const selectedCamera = useSelectedCamera();
+    const trackTimeline = useTrackTimeline();
+    // Begin/end as the playhead counts them; null when stored frames already match it.
+    const timelineSpan = computed(() => trackTimeline.range(props.track.id));
+    const displayBegin = computed(() => timelineSpan.value?.[0] ?? props.track.begin);
+    const displayEnd = computed(() => timelineSpan.value?.[1] ?? props.track.end);
+    function seekBegin() {
+      if (timelineSpan.value) trackTimeline.seekSlot(timelineSpan.value[0]);
+      else emit('seek', props.track.begin);
+    }
+    function seekEnd() {
+      if (timelineSpan.value) trackTimeline.seekSlot(timelineSpan.value[1]);
+      else emit('seek', props.track.end);
+    }
 
     /**
      * Recomputes when the track prop is rebuilt, which TrackList does whenever the annotation
@@ -177,7 +192,11 @@ export default defineComponent({
       style,
       frame: frameRef,
       keyframeDisabled,
+      displayBegin,
+      displayEnd,
       /* methods */
+      seekBegin,
+      seekEnd,
       gotoNext,
       gotoPrevious,
       toggleInterpolation,
@@ -197,6 +216,10 @@ export default defineComponent({
     :toggle-keyframe="toggleKeyframe"
     :toggle-interpolation="toggleInterpolation"
     :toggle-all-interpolation="toggleAllInterpolation"
+    :display-begin="displayBegin"
+    :display-end="displayEnd"
+    :seek-begin="seekBegin"
+    :seek-end="seekEnd"
     @seek="$emit('seek', $event)"
   />
   <side-bar-track-item-view
@@ -213,6 +236,8 @@ export default defineComponent({
     :toggle-all-interpolation="toggleAllInterpolation"
     :goto-previous="gotoPrevious"
     :goto-next="gotoNext"
+    :seek-begin="seekBegin"
+    :seek-end="seekEnd"
     @seek="$emit('seek', $event)"
   />
 </template>
diff --git a/client/src/components/Tracks/TrackList.spec.ts b/client/src/components/Tracks/TrackList.spec.ts
index 9e123aa8d..17217e1a3 100644
--- a/client/src/components/Tracks/TrackList.spec.ts
+++ b/client/src/components/Tracks/TrackList.spec.ts
@@ -27,6 +27,7 @@ const state = vi.hoisted(() => ({
   cameraStore: null as unknown as MockCameraStore,
   trackFilters: null as unknown as MockTrackFilters,
   removeTrack: vi.fn(),
+  timelineRanges: new Map<number, [number, number]>(),
 }));
 
 vi.mock('dive-common/vue-utilities/prompt-service', () => ({
@@ -56,6 +57,10 @@ vi.mock('../../provides', () => ({
   useMultiSelectList: () => ref([]),
   useCameraStore: () => state.cameraStore,
   usePendingSaveCount: () => ref(0),
+  useTrackTimeline: () => ({
+    range: (id: number) => state.timelineRanges.get(id) ?? null,
+    seekSlot: vi.fn(),
+  }),
 }));
 
 function sortedTrack(track: Track) {
@@ -117,6 +122,21 @@ function mountList(
   return { wrapper, vm: child };
 }
 
+beforeEach(() => {
+  state.timelineRanges = new Map();
+});
+
+describe('TrackList on an aligned timeline', () => {
+  it('sorts by start at the timeline slots the list shows, not the stored frames', () => {
+    const storedLate = new Track(1, { begin: 9, end: 9, confidencePairs: [['root', 0.9]] });
+    const storedEarly = new Track(2, { begin: 0, end: 0, confidencePairs: [['root', 0.9]] });
+    state.timelineRanges = new Map([[1, [1, 2]], [2, [5, 6]]]);
+    const { vm } = mountList([storedLate, storedEarly], [0, 0], false);
+    vm.handleSort('start');
+    expect(vm.filteredTracks.map(({ annotation }) => annotation.id)).toEqual([2, 1]);
+  });
+});
+
 describe('TrackList hierarchy display', () => {
   it.each([
     ['monotone leaf', [['root', 0.9], ['child', 0.8], ['leaf', 0.7]], 2, 'leaf'],
diff --git a/client/src/components/Tracks/TrackList.vue b/client/src/components/Tracks/TrackList.vue
index 4290ae0cc..94375b8e3 100644
--- a/client/src/components/Tracks/TrackList.vue
+++ b/client/src/components/Tracks/TrackList.vue
@@ -21,6 +21,7 @@ import {
   useMultiSelectList,
   useCameraStore,
   usePendingSaveCount,
+  useTrackTimeline,
 } from '../../provides';
 import useVirtualScrollTo from '../../use/useVirtualScrollTo';
 import { getSuppressedTrackIds, suppressionTypeResolver } from '../../use/suppression';
@@ -85,6 +86,7 @@ export default defineComponent({
     const editingModeRef = useEditingMode();
     const selectedTrackIdRef = useSelectedTrackId();
     const cameraStore = useCameraStore();
+    const trackTimeline = useTrackTimeline();
     const pendingSaveCount = usePendingSaveCount();
     const filteredTracksRef = trackFilters.filteredAnnotations;
     const typeStylingRef = useTrackStyleManager().typeStyling;
@@ -231,6 +233,10 @@ export default defineComponent({
         }
       });
 
+      // Sort by the frames the list shows, which are timeline slots under an aligned timeline.
+      const spanOf = (track: TrackProjection): [number, number] => (
+        trackTimeline.range(track.id) ?? [track.begin, track.end]
+      );
       sorted.sort((a, b) => {
         const trackA = projections.get(a.annotation.id);
         const trackB = projections.get(b.annotation.id);
@@ -263,10 +269,10 @@ export default defineComponent({
             return (trackA.trackId - trackB.trackId) * direction;
           case 'start':
           case 'startTime':
-            return (trackA.begin - trackB.begin) * direction;
+            return (spanOf(trackA)[0] - spanOf(trackB)[0]) * direction;
           case 'end':
           case 'endTime':
-            return (trackA.end - trackB.end) * direction;
+            return (spanOf(trackA)[1] - spanOf(trackB)[1]) * direction;
           case 'confidence': {
             const confA = displayConfidence(trackA, a.context.confidencePairIndex);
             const confB = displayConfidence(trackB, b.context.confidencePairIndex);
diff --git a/client/src/components/Tracks/bottombar/BottomBarTrackItemView.vue b/client/src/components/Tracks/bottombar/BottomBarTrackItemView.vue
index bd4858f3d..fb5f9671f 100644
--- a/client/src/components/Tracks/bottombar/BottomBarTrackItemView.vue
+++ b/client/src/components/Tracks/bottombar/BottomBarTrackItemView.vue
@@ -30,6 +30,10 @@ export default defineComponent({
     toggleKeyframe: { type: Function as PropType<() => void>, required: true },
     toggleInterpolation: { type: Function as PropType<() => void>, required: true },
     toggleAllInterpolation: { type: Function as PropType<() => void>, required: true },
+    displayBegin: { type: Number, required: true },
+    displayEnd: { type: Number, required: true },
+    seekBegin: { type: Function as PropType<() => void>, required: true },
+    seekEnd: { type: Function as PropType<() => void>, required: true },
   },
   setup(props) {
     const handler = useHandler();
@@ -91,8 +95,8 @@ export default defineComponent({
       return `${minutes}:${seconds.toString().padStart(2, '0')}.${ms.toString().padStart(3, '0').slice(0, 2)}`;
     };
 
-    const startTimestamp = computed(() => formatTimestamp(props.track.begin));
-    const endTimestamp = computed(() => formatTimestamp(props.track.end));
+    const startTimestamp = computed(() => formatTimestamp(props.displayBegin));
+    const endTimestamp = computed(() => formatTimestamp(props.displayEnd));
 
     const trackAttributeColumns = computed(
       () => (props.columnVisibility?.attributeColumns || []).filter((key: string) => key.startsWith('track_')),
@@ -404,22 +408,22 @@ export default defineComponent({
     <span
       v-if="!columnVisibility || columnVisibility.startFrame"
       class="track-frame-start clickable"
-      @click.stop="$emit('seek', track.begin)"
-    >{{ track.begin }}</span>
+      @click.stop="seekBegin"
+    >{{ displayBegin }}</span>
     <span
       v-if="!columnVisibility || columnVisibility.endFrame"
       class="track-frame-end clickable"
-      @click.stop="$emit('seek', track.end)"
-    >{{ track.end }}</span>
+      @click.stop="seekEnd"
+    >{{ displayEnd }}</span>
     <span
       v-if="columnVisibility?.startTimestamp"
       class="track-timestamp clickable"
-      @click.stop="$emit('seek', track.begin)"
+      @click.stop="seekBegin"
     >{{ startTimestamp }}</span>
     <span
       v-if="columnVisibility?.endTimestamp"
       class="track-timestamp clickable"
-      @click.stop="$emit('seek', track.end)"
+      @click.stop="seekEnd"
     >{{ endTimestamp }}</span>
     <template v-for="attrKey in trackAttributeColumns">
       <input
@@ -498,8 +502,8 @@ export default defineComponent({
         { bind: 'k', handler: toggleKeyframe },
         { bind: 'i', handler: toggleInterpolation },
         { bind: 'ctrl+i', handler: toggleAllInterpolation },
-        { bind: 'home', handler: () => $emit('seek', track.begin) },
-        { bind: 'end', handler: () => $emit('seek', track.end) },
+        { bind: 'home', handler: seekBegin },
+        { bind: 'end', handler: seekEnd },
       ]"
     />
   </div>
diff --git a/client/src/components/Tracks/sidebar/SideBarTrackItemView.spec.ts b/client/src/components/Tracks/sidebar/SideBarTrackItemView.spec.ts
index 7bd9f3435..845315d09 100644
--- a/client/src/components/Tracks/sidebar/SideBarTrackItemView.spec.ts
+++ b/client/src/components/Tracks/sidebar/SideBarTrackItemView.spec.ts
@@ -73,6 +73,8 @@ describe('SideBarTrackItemView classification editing', () => {
       toggleAllInterpolation: vi.fn(),
       gotoPrevious: vi.fn(),
       gotoNext: vi.fn(),
+      seekBegin: vi.fn(),
+      seekEnd: vi.fn(),
       editing: false,
     });
     vm.setTrackType('new leaf');
@@ -107,6 +109,8 @@ describe('SideBarTrackItemView classification editing', () => {
       toggleAllInterpolation: vi.fn(),
       gotoPrevious: vi.fn(),
       gotoNext: vi.fn(),
+      seekBegin: vi.fn(),
+      seekEnd: vi.fn(),
       editing: false,
     });
     vm.editNotesValue = ' reviewed ';
diff --git a/client/src/components/Tracks/sidebar/SideBarTrackItemView.vue b/client/src/components/Tracks/sidebar/SideBarTrackItemView.vue
index 4d8c91131..9cab98b74 100644
--- a/client/src/components/Tracks/sidebar/SideBarTrackItemView.vue
+++ b/client/src/components/Tracks/sidebar/SideBarTrackItemView.vue
@@ -38,6 +38,8 @@ export default defineComponent({
     toggleAllInterpolation: { type: Function as PropType<() => void>, required: true },
     gotoPrevious: { type: Function as PropType<() => void>, required: true },
     gotoNext: { type: Function as PropType<() => void>, required: true },
+    seekBegin: { type: Function as PropType<() => void>, required: true },
+    seekEnd: { type: Function as PropType<() => void>, required: true },
     editing: { type: Boolean, required: true },
   },
   setup(props) {
@@ -221,8 +223,8 @@ export default defineComponent({
             { bind: 'k', handler: toggleKeyframe },
             { bind: 'i', handler: toggleInterpolation },
             { bind: 'ctrl+i', handler: toggleAllInterpolation },
-            { bind: 'home', handler: () => $emit('seek', track.begin) },
-            { bind: 'end', handler: () => $emit('seek', track.end) },
+            { bind: 'home', handler: seekBegin },
+            { bind: 'end', handler: seekEnd },
           ]"
         />
         <tooltip-btn
@@ -267,7 +269,7 @@ export default defineComponent({
         <tooltip-btn
           icon="mdi-chevron-double-left"
           tooltip-text="Seek to track beginning"
-          @click="$emit('seek', track.begin)"
+          @click="seekBegin"
         />
         <tooltip-btn
           icon="mdi-chevron-left"
@@ -282,14 +284,14 @@ export default defineComponent({
         <tooltip-btn
           icon="mdi-chevron-double-right"
           tooltip-text="Seek to track end"
-          @click="$emit('seek', track.end)"
+          @click="seekEnd"
         />
       </template>
       <tooltip-btn
         v-else
         icon="mdi-map-marker"
         tooltip-text="Seek to detection"
-        @click="$emit('seek', track.begin)"
+        @click="seekBegin"
       />
       <tooltip-btn
         v-if="!merging"
diff --git a/client/src/components/annotators/linkedViewers/useAlignedNavigation.spec.ts b/client/src/components/annotators/linkedViewers/useAlignedNavigation.spec.ts
index 3c86757ef..c13ecdbf8 100644
--- a/client/src/components/annotators/linkedViewers/useAlignedNavigation.spec.ts
+++ b/client/src/components/annotators/linkedViewers/useAlignedNavigation.spec.ts
@@ -137,6 +137,7 @@ function makeHarness() {
   return {
     eo,
     ir,
+    controllers,
     cameraSync,
     resizing,
     resizeTrigger,
@@ -168,6 +169,37 @@ describe('useAlignedNavigation', () => {
     expect(ir.zoom()).toBeCloseTo(Math.log2(8 / (400 / VIEWPORT_PX)), 6);
   });
 
+  it('re-fits once late imagery lands, but not over a zoom the user has since set', async () => {
+    const h = makeHarness();
+    h.alignedView.setTransforms('eo', { eo: IDENTITY, ir: IDENTITY });
+    h.alignedView.setEnabled(true);
+    await nextTick();
+    await nextTick();
+    // The user zooms in before any frame has landed on the reference pane.
+    h.eo.zoom(3);
+    h.eo.center({ x: 50, y: 40 });
+    h.controllers.eo.imageRevision.value += 1;
+    await nextTick();
+    expect(h.eo.zoom()).toBe(3);
+    expect(h.eo.center()).toEqual({ x: 50, y: 40 });
+  });
+
+  it('re-fits when late imagery lands on an untouched Align-on view', async () => {
+    const h = makeHarness();
+    h.alignedView.setTransforms('eo', { eo: IDENTITY, ir: IDENTITY });
+    h.alignedView.setEnabled(true);
+    await nextTick();
+    await nextTick();
+    const fitted = { zoom: h.eo.zoom(), center: { ...h.eo.center() } };
+    h.controllers.eo.originalBounds.value = {
+      left: 0, top: 0, right: 800, bottom: 600,
+    };
+    h.controllers.eo.imageRevision.value += 1;
+    await nextTick();
+    expect(h.eo.zoom()).not.toBe(fitted.zoom);
+    expect(h.eo.center()).toEqual({ x: 400, y: 300 });
+  });
+
   it('clears GeoJS pan/zoom clamp on activation so large-image can show the reference FOV', async () => {
     const { eo, ir, alignedView } = makeHarness();
     expect(ir.clampZoom()).toBe(true);
diff --git a/client/src/components/annotators/linkedViewers/useAlignedNavigation.ts b/client/src/components/annotators/linkedViewers/useAlignedNavigation.ts
index d1ea5a47e..f0590a78d 100644
--- a/client/src/components/annotators/linkedViewers/useAlignedNavigation.ts
+++ b/client/src/components/annotators/linkedViewers/useAlignedNavigation.ts
@@ -193,6 +193,23 @@ export default function useAlignedNavigation(
     });
   }
 
+  // The reference view the last snap produced, so a late re-snap can tell whether the user has zoomed since.
+  let snappedView: { zoom: number; x: number; y: number } | null = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function referenceView(map: any) {
+    const center = map.center();
+    return { zoom: map.zoom(), x: center.x, y: center.y };
+  }
+  function referenceUnchangedSinceSnap() {
+    const reference = alignedView.reference.value;
+    const source = reference ? viewer(reference) : null;
+    if (!source || !snappedView) return true;
+    const now = referenceView(source);
+    return Math.abs(now.zoom - snappedView.zoom) < 1e-6
+      && Math.abs(now.x - snappedView.x) < 1e-3
+      && Math.abs(now.y - snappedView.y) < 1e-3;
+  }
+
   function snapFromReference() {
     if (!alignedView.active.value) {
       return;
@@ -221,6 +238,7 @@ export default function useAlignedNavigation(
         // view the reference currently has.
       }
     });
+    snappedView = referenceView(source);
     link(reference)();
   }
 
@@ -260,14 +278,14 @@ export default function useAlignedNavigation(
     if (active && !wasActive) {
       snapFromReference();
       nextTick(() => {
-        if (!alignedView.active.value) {
+        if (!alignedView.active.value || !referenceUnchangedSinceSnap()) {
           return;
         }
         snapFromReference();
         if (typeof window !== 'undefined'
           && typeof window.requestAnimationFrame === 'function') {
           window.requestAnimationFrame(() => {
-            if (alignedView.active.value) {
+            if (alignedView.active.value && referenceUnchangedSinceSnap()) {
               snapFromReference();
             }
           });
@@ -278,7 +296,8 @@ export default function useAlignedNavigation(
           const { imageRevision } = aggregateController.value.getController(camera);
           const stop = watch(imageRevision, () => {
             stop();
-            if (alignedView.active.value) {
+            // Late imagery re-fits the Align-on view, but never over a zoom the user has since set.
+            if (alignedView.active.value && referenceUnchangedSinceSnap()) {
               snapFromReference();
             }
           });
diff --git a/client/src/components/annotators/mediaControllerType.ts b/client/src/components/annotators/mediaControllerType.ts
index 002225814..535973cdf 100644
--- a/client/src/components/annotators/mediaControllerType.ts
+++ b/client/src/components/annotators/mediaControllerType.ts
@@ -136,7 +136,7 @@ export interface MediaController extends AggregateMediaController {
   flick: Readonly<Ref<number>>;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   geoViewerRef: Readonly<Ref<any>>;
-  /** @deprecated may be removed in a future release */
+  /** The frame actually on screen: it trails `frame` until an image loads or a video seek lands. */
   syncedFrame: Readonly<Ref<number>>;
   /**
    * False when an aligned-timeline slot has no frame for this camera (see
@@ -144,6 +144,11 @@ export interface MediaController extends AggregateMediaController {
    * draw annotations for the stale `frame` value left over from before.
    */
   hasFrame: Readonly<Ref<boolean>>;
+  /**
+   * Frame annotations are drawn at, minus this camera's unapplied time offset: `frame` for video,
+   * `syncedFrame` for images so boxes wait for their image.
+   */
+  annotationFrame: Readonly<Ref<number>>;
   /**
    * Bumped whenever the annotator redraws its media quad: the async <img>
    * swap after a seek finishes loading, an image-enhancement change (the
diff --git a/client/src/components/annotators/useMediaController.spec.ts b/client/src/components/annotators/useMediaController.spec.ts
index 4798e5b9a..6567534d6 100644
--- a/client/src/components/annotators/useMediaController.spec.ts
+++ b/client/src/components/annotators/useMediaController.spec.ts
@@ -1,4 +1,6 @@
-import { defineComponent, ref } from 'vue';
+import {
+  defineComponent, nextTick, ref, type Ref,
+} from 'vue';
 import { mount } from '@vue/test-utils';
 import { useMediaController } from './useMediaController';
 import type { AlignedFrameResolver } from './mediaControllerType';
@@ -11,7 +13,7 @@ function noop() { /* unused setVolume/setSpeed stub */ }
  * GeoJS/DOM, so camera controllers can be registered directly here with
  * mocked seek/play/pause -- no need to mount real annotator components.
  */
-function mountMediaController() {
+function mountMediaController(kind: 'image-sequence' | 'video' = 'image-sequence') {
   const seekA = vi.fn();
   const playA = vi.fn();
   const pauseA = vi.fn();
@@ -24,10 +26,10 @@ function mountMediaController() {
   const Host = defineComponent({
     setup() {
       composable = useMediaController();
-      composable.initialize('A', 'image-sequence', {
+      composable.initialize('A', kind, {
         seek: seekA, play: playA, pause: pauseA, setVolume: noop, setSpeed: noop,
       });
-      composable.initialize('B', 'image-sequence', {
+      composable.initialize('B', kind, {
         seek: seekB, play: playB, pause: pauseB, setVolume: noop, setSpeed: noop,
       });
       return {};
@@ -193,6 +195,44 @@ describe('useMediaController', () => {
     }
   });
 
+  it('an all-video rig plays natively: no tick, the slot follows the reference camera', () => {
+    vi.useFakeTimers();
+    try {
+      const { composable, mocks } = mountMediaController('video');
+      const {
+        seekA, seekB, pauseA, pauseB,
+      } = mocks;
+      composable.setAlignedFrameResolver(makeShiftedResolver());
+      composable.aggregateController.value.seek(0);
+      seekA.mockClear();
+      seekB.mockClear();
+
+      composable.aggregateController.value.play();
+      expect(composable.externallyDriven.value).toBe(false);
+      // Aligned once at play, then left alone: no per-tick seeks.
+      expect(seekA).toHaveBeenCalledTimes(1);
+      vi.advanceTimersByTime(3000);
+      expect(seekA).toHaveBeenCalledTimes(1);
+      expect(seekB).toHaveBeenCalledTimes(1);
+
+      // The reference camera's own clock advances the global slot.
+      const a = composable.aggregateController.value.getController('A');
+      (a.frame as Ref<number>).value = 1;
+      return nextTick().then(() => {
+        expect(composable.aggregateController.value.frame.value).toBe(2);
+        composable.aggregateController.value.pause();
+        expect(composable.externallyDriven.value).toBe(true);
+        expect(pauseA).toHaveBeenCalled();
+        expect(pauseB).toHaveBeenCalled();
+        // Pause snaps every pane back onto the slot.
+        expect(seekA).toHaveBeenLastCalledWith(1);
+        expect(seekB).toHaveBeenLastCalledWith(2);
+      });
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it('pause() stops the centralized tick', () => {
     vi.useFakeTimers();
     try {
@@ -254,10 +294,9 @@ describe('useMediaController', () => {
     expect(composable.aggregateController.value.alignedGapSlots.value).toEqual([]);
   });
 
-  it('installing a resolver immediately performs an aligned seek to slot 0', () => {
+  it('installing a first resolver seeks to the slot showing the current frame', () => {
     const { composable, mocks } = mountMediaController();
-    // Gap at slot 0: A has no frame there and must blank right away rather
-    // than continuing to show its local frame 0 until the first user seek.
+    // Both cameras sit at local frame 0; A's frame 0 lives at slot 1 here.
     const resolver: AlignedFrameResolver = {
       slotCount: ref(3),
       frameRate: ref(2),
@@ -270,9 +309,113 @@ describe('useMediaController', () => {
       gapSlots: ref([0]),
     };
     composable.setAlignedFrameResolver(resolver);
-    expect(mocks.seekA).toHaveBeenCalledWith(undefined);
-    expect(mocks.seekB).toHaveBeenCalledWith(0);
-    expect(composable.aggregateController.value.frame.value).toBe(0);
+    expect(mocks.seekA).toHaveBeenLastCalledWith(0);
+    expect(mocks.seekB).toHaveBeenLastCalledWith(1);
+    expect(composable.aggregateController.value.frame.value).toBe(1);
+  });
+
+  it('replacing a resolver keeps the first camera\'s displayed frame instead of jumping to slot 0', () => {
+    const { composable, mocks } = mountMediaController();
+    composable.setAlignedFrameResolver(makeGappedResolver(10));
+    composable.aggregateController.value.seek(5);
+    // A Time Offset nudge: B now runs three frames ahead of A, so the timeline
+    // grows a lead of three slots where A has no frame.
+    const shifted: AlignedFrameResolver = {
+      slotCount: ref(13),
+      frameRate: ref(2),
+      resolveSlot: (f: number) => ({
+        A: f < 3 ? undefined : f - 3,
+        B: f < 10 ? f : undefined,
+      }),
+      resolveGlobalSlot: (camera: string, localFrame: number) => (
+        camera === 'A' ? localFrame + 3 : localFrame),
+      gapSlots: ref([0, 1, 2, 10, 11, 12]),
+    };
+    composable.setAlignedFrameResolver(shifted);
+    // A stays on local frame 5, now global slot 8; B follows to its frame there.
+    expect(composable.aggregateController.value.frame.value).toBe(8);
+    expect(mocks.seekA).toHaveBeenLastCalledWith(5);
+    expect(mocks.seekB).toHaveBeenLastCalledWith(8);
+  });
+
+  it('a first resolver keeps the frame positional playback was showing', () => {
+    const { composable, mocks } = mountMediaController();
+    // The mock annotators never report back, so place the frames directly.
+    (composable.aggregateController.value.getController('A').frame as Ref<number>).value = 4;
+    (composable.aggregateController.value.getController('B').frame as Ref<number>).value = 4;
+    // B now runs three frames ahead of A: the timeline gains a three-slot lead.
+    const shifted: AlignedFrameResolver = {
+      slotCount: ref(13),
+      frameRate: ref(2),
+      resolveSlot: (f: number) => ({
+        A: f < 3 ? undefined : f - 3,
+        B: f < 10 ? f : undefined,
+      }),
+      resolveGlobalSlot: (camera: string, localFrame: number) => (
+        camera === 'A' ? localFrame + 3 : localFrame),
+      gapSlots: ref([0, 1, 2, 10, 11, 12]),
+    };
+    composable.setAlignedFrameResolver(shifted);
+    expect(composable.aggregateController.value.frame.value).toBe(7);
+    expect(mocks.seekA).toHaveBeenLastCalledWith(4);
+    expect(mocks.seekB).toHaveBeenLastCalledWith(7);
+  });
+
+  it('annotationFrame trails the video frame by the camera\'s unapplied shift', async () => {
+    const { composable } = mountMediaController();
+    const a = composable.aggregateController.value.getController('A');
+    const b = composable.aggregateController.value.getController('B');
+    (a.frame as Ref<number>).value = 12;
+    (a.syncedFrame as Ref<number>).value = 12;
+    (b.frame as Ref<number>).value = 12;
+    (b.syncedFrame as Ref<number>).value = 12;
+    await nextTick();
+    expect(a.annotationFrame.value).toBe(12);
+    composable.setAnnotationFrameShifts({ A: 9 });
+    await nextTick();
+    expect(a.annotationFrame.value).toBe(3);
+    expect(b.annotationFrame.value).toBe(12);
+    composable.setAnnotationFrameShifts({});
+    await nextTick();
+    expect(a.annotationFrame.value).toBe(12);
+  });
+
+  it('holds an image pane\'s old shift until the image the new shift pairs with is drawn', async () => {
+    const { composable } = mountMediaController('image-sequence');
+    const a = composable.aggregateController.value.getController('A');
+    (a.frame as Ref<number>).value = 10;
+    (a.syncedFrame as Ref<number>).value = 10;
+    composable.setAnnotationFrameShifts({ A: 2 });
+    await nextTick();
+    expect(a.annotationFrame.value).toBe(8);
+    // A one-frame nudge seeks the pane on and raises the shift in the same tick.
+    (a.frame as Ref<number>).value = 11;
+    composable.setAnnotationFrameShifts({ A: 3 });
+    await nextTick();
+    expect(a.annotationFrame.value).toBe(8);
+    (a.syncedFrame as Ref<number>).value = 11;
+    await nextTick();
+    expect(a.annotationFrame.value).toBe(8);
+  });
+
+  it('annotationFrame follows an image pane\'s drawn frame, not one still loading', () => {
+    const { composable } = mountMediaController('image-sequence');
+    const a = composable.aggregateController.value.getController('A');
+    (a.frame as Ref<number>).value = 5;
+    (a.syncedFrame as Ref<number>).value = 4;
+    expect(a.annotationFrame.value).toBe(4);
+    (a.syncedFrame as Ref<number>).value = 5;
+    expect(a.annotationFrame.value).toBe(5);
+  });
+
+  it('annotationFrame follows a video pane\'s requested frame and shift at once', () => {
+    const { composable } = mountMediaController('video');
+    const a = composable.aggregateController.value.getController('A');
+    (a.frame as Ref<number>).value = 5;
+    (a.syncedFrame as Ref<number>).value = 4;
+    expect(a.annotationFrame.value).toBe(5);
+    composable.setAnnotationFrameShifts({ A: 2 });
+    expect(a.annotationFrame.value).toBe(3);
   });
 
   it('re-applies the current aligned slot when a camera registers after the resolver is installed', async () => {
diff --git a/client/src/components/annotators/useMediaController.ts b/client/src/components/annotators/useMediaController.ts
index c904e4e04..ff761ca58 100644
--- a/client/src/components/annotators/useMediaController.ts
+++ b/client/src/components/annotators/useMediaController.ts
@@ -18,6 +18,23 @@ import type {
 } from './mediaControllerType';
 import type { CameraImage } from '../../layers/cameraImage';
 
+interface PaneView {
+  zoom: number;
+  center: { x: number; y: number };
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function viewOf(map: any): PaneView {
+  const center = map.center();
+  return { zoom: map.zoom(), center: { x: center.x, y: center.y } };
+}
+
+function sameView(a: PaneView, b: PaneView) {
+  return Math.abs(a.zoom - b.zoom) < 1e-6
+    && Math.abs(a.center.x - b.center.x) < 1e-3
+    && Math.abs(a.center.y - b.center.y) < 1e-3;
+}
+
 const AggregateControllerSymbol = Symbol('aggregate-controller');
 const CameraInitializerSymbol = Symbol('camera-initializer');
 const bus = new Vue();
@@ -144,7 +161,14 @@ export function useMediaController(options?: {
   // that must NOT be deep-reactive-converted/auto-unwrapped by a plain ref().
   const alignedFrameResolver: Ref<AlignedFrameResolver | null> = shallowRef(null);
   const alignedCurrentFrame: Ref<number> = ref(0);
-  const externallyDriven = computed(() => alignedFrameResolver.value !== null);
+  // Per camera: frames its annotations lag its video by until a time offset is applied to them.
+  const annotationFrameShifts: Ref<Record<string, number>> = ref({});
+  // All-video rigs under an aligned timeline let the <video> elements free-run instead of ticking.
+  const alignedNativePlayback = ref(false);
+  let stopNativePlaybackWatch: (() => void) | null = null;
+  const externallyDriven = computed(
+    () => alignedFrameResolver.value !== null && !alignedNativePlayback.value,
+  );
   const alignedGapSlots = computed(() => alignedFrameResolver.value?.gapSlots.value ?? []);
   let alignedPlaybackTimer: ReturnType<typeof setTimeout> | undefined;
   const emptyControllerFrame = ref(0);
@@ -195,15 +219,28 @@ export function useMediaController(options?: {
    */
   function setAlignedFrameResolver(resolver: AlignedFrameResolver | null) {
     stopAlignedPlaybackTimer();
+    const previous = alignedFrameResolver.value;
+    const previousSlot = alignedCurrentFrame.value;
     alignedFrameResolver.value = resolver;
-    if (resolver) {
-      // Immediately perform an aligned seek to slot 0 so that any camera with
-      // no frame at that slot blanks right away, rather than continuing to
-      // show its own local frame 0 until the first user-driven seek.
-      alignedSeek(resolver, 0);
-    } else {
+    if (!resolver) {
       alignedCurrentFrame.value = 0;
+      return;
     }
+    // Keep the instant on screen: the first camera's displayed frame, from the old timeline or positional playback.
+    const shown = previous ? previous.resolveSlot(previousSlot) : null;
+    let kept: number | undefined;
+    subControllers.forEach((mc) => {
+      const local = shown ? shown[mc.cameraName.value] : mc.frame.value;
+      if (kept === undefined && local !== undefined) {
+        kept = resolver.resolveGlobalSlot(mc.cameraName.value, local);
+      }
+    });
+    alignedSeek(resolver, kept ?? 0);
+  }
+
+  /** Set how far each camera's annotations trail its video (see MediaController.annotationFrame). */
+  function setAnnotationFrameShifts(shifts: Record<string, number>) {
+    annotationFrameShifts.value = { ...shifts };
   }
 
   /**
@@ -273,14 +310,25 @@ export function useMediaController(options?: {
       }
       const size = containerRef.value.getBoundingClientRect();
       const mapSize = geoViewerRef.value.size();
-      if (size.width !== mapSize.width || size.height !== mapSize.height) {
+      // Sub-pixel layout jitter is not a resize; resizing refits the pane and drops its zoom.
+      if (Math.round(size.width) !== Math.round(mapSize.width)
+        || Math.round(size.height) !== Math.round(mapSize.height)) {
         resized = true;
         pendingResizes.push(() => {
-          if (geoViewerRef.value === undefined) {
+          const map = geoViewerRef.value;
+          if (map === undefined) {
             return;
           }
-          geoViewerRef.value.size(size);
-          mc.resetZoom();
+          // A pane the user zoomed or panned keeps its view; one still at its last fit refits to the new size.
+          const view = viewOf(map);
+          const fit = fitViews[camera];
+          map.size(size);
+          if (!fit || sameView(view, fit)) {
+            mc.resetZoom();
+          } else {
+            map.zoom(view.zoom);
+            map.center(view.center);
+          }
         });
       }
     });
@@ -328,12 +376,20 @@ export function useMediaController(options?: {
    * it.
    */
   let resetZoomOverride: (() => boolean) | null = null;
+  // Each pane's view right after its last reset, so a resize can tell a fitted pane from a zoomed one.
+  const fitViews: Record<string, PaneView> = {};
+  function recordFitViews() {
+    Object.entries(geoViewers).forEach(([camera, viewerRef]) => {
+      if (viewerRef.value) fitViews[camera] = viewOf(viewerRef.value);
+    });
+  }
   function setResetZoomOverride(override: (() => boolean) | null) {
     resetZoomOverride = override;
   }
 
   function aggregateResetZoom() {
     if (resetZoomOverride && resetZoomOverride()) {
+      recordFitViews();
       return;
     }
     subControllers.forEach((mc) => mc.resetZoom());
@@ -472,6 +528,7 @@ export function useMediaController(options?: {
       const zoomAndCenter = geoViewerRef.value.zoomAndCenterFromBounds(data.originalBounds, 0);
       geoViewerRef.value.zoom(zoomAndCenter.zoom);
       geoViewerRef.value.center(zoomAndCenter.center);
+      fitViews[camera] = viewOf(geoViewerRef.value);
     }
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars -- retained for MediaController API compatibility
@@ -664,6 +721,16 @@ export function useMediaController(options?: {
       }
     });
 
+    // Image panes adopt a changed time-offset shift only once the image paired with it is drawn.
+    const settledShift = ref(annotationFrameShifts.value[cameraName] ?? 0);
+    watch(
+      [() => state[camera].syncedFrame, () => state[camera].frame,
+        () => annotationFrameShifts.value[cameraName] ?? 0],
+      ([synced, frame, shift]) => {
+        if (synced === frame) settledShift.value = shift;
+      },
+      { flush: 'post' },
+    );
     const mediaController: MediaController = {
       mediaKind,
       ready: toRef(state[camera], 'ready'),
@@ -682,6 +749,10 @@ export function useMediaController(options?: {
       speed: toRef(state[camera], 'speed'),
       syncedFrame: toRef(state[camera], 'syncedFrame'),
       hasFrame: toRef(state[camera], 'hasFrame'),
+      // Video draws at the requested frame, ahead of the picture while a seek lands, as main always has.
+      annotationFrame: computed(() => (mediaKind === 'video'
+        ? state[camera].frame - (annotationFrameShifts.value[cameraName] ?? 0)
+        : state[camera].syncedFrame - settledShift.value)),
       imageRevision: toRef(state[camera], 'imageRevision'),
       frameTexture: toRef(state[camera], 'frameTexture'),
       originalBounds: toRef(state[camera], 'originalBounds'),
@@ -812,17 +883,52 @@ export function useMediaController(options?: {
   }
 
   function aggregatePause() {
+    const wasNative = alignedNativePlayback.value;
+    if (stopNativePlaybackWatch) {
+      stopNativePlaybackWatch();
+      stopNativePlaybackWatch = null;
+    }
+    alignedNativePlayback.value = false;
     subControllers.forEach((mc) => mc.pause());
     stopAlignedPlaybackTimer();
+    const resolver = alignedFrameResolver.value;
+    if (wasNative && resolver) {
+      // Free-running videos drift by a frame or two; snap every pane back to the slot.
+      alignedSeek(resolver, alignedCurrentFrame.value);
+    }
   }
 
   function aggregatePlay() {
+    const resolver = alignedFrameResolver.value;
+    if (resolver && subControllers.length && subControllers.every((mc) => mc.mediaKind === 'video')) {
+      // Seeking two videos every tick cannot keep up; align them once and let them play.
+      stopAlignedPlaybackTimer();
+      alignedSeek(resolver, alignedCurrentFrame.value);
+      alignedNativePlayback.value = true;
+      const reference = subControllers[0];
+      const stopFrame = watch(reference.frame, (local) => {
+        const slot = resolver.resolveGlobalSlot(reference.cameraName.value, local);
+        if (slot !== undefined) {
+          alignedCurrentFrame.value = slot;
+        }
+      });
+      const stopPlaying = watch(reference.playing, (playing) => {
+        if (!playing) {
+          aggregatePause();
+        }
+      });
+      stopNativePlaybackWatch = () => {
+        stopFrame();
+        stopPlaying();
+      };
+      subControllers.forEach((mc) => mc.play());
+      return;
+    }
     // Each camera still flips its own `playing` UI state; when a resolver is
     // set, ImageAnnotator/VideoAnnotator skip starting their own internal
     // frame-advance loop (see externallyDriven) and this centralized tick
     // drives seeks instead.
     subControllers.forEach((mc) => mc.play());
-    const resolver = alignedFrameResolver.value;
     if (!resolver) {
       return;
     }
@@ -891,6 +997,8 @@ export function useMediaController(options?: {
     onResize,
     clear,
     setAlignedFrameResolver,
+    setAnnotationFrameShifts,
     setResetZoomOverride,
+    externallyDriven,
   };
 }
diff --git a/client/src/provides.ts b/client/src/provides.ts
index 449894b9b..6b03c3820 100644
--- a/client/src/provides.ts
+++ b/client/src/provides.ts
@@ -114,6 +114,17 @@ type VisibleModesType = Readonly<Ref<readonly VisibleAnnotationTypes[]>>;
 const ReadOnlyModeSymbol = Symbol('readOnlyMode');
 type ReadOnylModeType = Readonly<Ref<boolean>>;
 
+// True when editing is paused only because a camera's time offset is not yet applied to its annotations.
+const OffsetEditLockSymbol = Symbol('offsetEditLock');
+type OffsetEditLockType = Readonly<Ref<boolean>>;
+
+// A track's span on the playback timeline, which differs from its stored frames under an aligned timeline.
+const TrackTimelineSymbol = Symbol('trackTimeline');
+interface TrackTimelineType {
+  range: (id: AnnotationId) => [number, number] | null;
+  seekSlot: (slot: number) => void;
+}
+
 const ImageEnhancementsSymbol = Symbol('imageEnhancements');
 type ImageEnhancementsType = Readonly<Ref<ImageEnhancements>>;
 
@@ -217,6 +228,8 @@ export interface Handler {
   unstageFromMerge(ids: AnnotationId[]): void;
   /* Reload Annotation File */
   reloadAnnotations(): Promise<void>;
+  /* Replace one camera's in-memory annotations with what persistence now holds */
+  reloadCameraAnnotations(camera: string): Promise<void>;
   setSVGFilters({
     brightness, contrast, saturation, sharpen, percentileStretch,
   }: {
@@ -281,6 +294,7 @@ function dummyHandler(handle: (name: string, args: unknown[]) => void): Handler
     groupEdit(...args) { handle('groupEdit', args); },
     unstageFromMerge(...args) { handle('unstageFromMerge', args); },
     reloadAnnotations(...args) { handle('reloadTracks', args); return Promise.resolve(); },
+    reloadCameraAnnotations(...args) { handle('reloadCameraAnnotations', args); return Promise.resolve(); },
     setSVGFilters(...args) { handle('setSVGFilter', args); },
     unlinkCameraTrack(...args) { handle('unlinkCameraTrack', args); },
     linkCameraTrack(...args) { handle('linkCameraTrack', args); },
@@ -330,6 +344,8 @@ export interface State {
   trackStyleManager: StyleManager;
   visibleModes: VisibleModesType;
   readOnlyMode: ReadOnylModeType;
+  offsetEditLock: OffsetEditLockType;
+  trackTimeline: TrackTimelineType;
   imageEnhancements: ImageEnhancementsType;
   percentileStretchSupported: Readonly<Ref<boolean>>;
   percentileHistogram: PercentileHistogramType;
@@ -411,6 +427,8 @@ function dummyState(): State {
     trackStyleManager: new StyleManager({ markChangesPending }),
     visibleModes: ref(['rectangle', 'text'] as VisibleAnnotationTypes[]),
     readOnlyMode: ref(false),
+    offsetEditLock: ref(false),
+    trackTimeline: { range: () => null, seekSlot: () => undefined },
     imageEnhancements: ref({
       brightness: 1,
       contrast: 1,
@@ -461,6 +479,8 @@ function provideAnnotator(state: State, handler: Handler, attributesFilters: Att
   provide(TimeSymbol, state.time);
   provide(VisibleModesSymbol, state.visibleModes);
   provide(ReadOnlyModeSymbol, state.readOnlyMode);
+  provide(OffsetEditLockSymbol, state.offsetEditLock);
+  provide(TrackTimelineSymbol, state.trackTimeline);
   provide(ImageEnhancementsSymbol, state.imageEnhancements);
   provide(PercentileStretchSupportedSymbol, state.percentileStretchSupported);
   provide(PercentileHistogramSymbol, state.percentileHistogram);
@@ -592,6 +612,12 @@ function useVisibleModes() {
 function useReadOnlyMode() {
   return use<ReadOnylModeType>(ReadOnlyModeSymbol);
 }
+function useOffsetEditLock() {
+  return use<OffsetEditLockType>(OffsetEditLockSymbol);
+}
+function useTrackTimeline() {
+  return use<TrackTimelineType>(TrackTimelineSymbol);
+}
 function useImageEnhancements() {
   return use<ImageEnhancementsType>(ImageEnhancementsSymbol);
 }
@@ -650,6 +676,8 @@ export {
   useTime,
   useVisibleModes,
   useReadOnlyMode,
+  useOffsetEditLock,
+  useTrackTimeline,
   useImageEnhancements,
   usePercentileStretchSupported,
   usePercentileHistogram,
diff --git a/client/src/use/useEventChart.spec.ts b/client/src/use/useEventChart.spec.ts
index c20b271db..d399f1b0d 100644
--- a/client/src/use/useEventChart.spec.ts
+++ b/client/src/use/useEventChart.spec.ts
@@ -65,3 +65,28 @@ describe('useEventChart display context', () => {
     })]);
   });
 });
+
+describe('useEventChart on an aligned timeline', () => {
+  it('draws the range and markers at timeline slots when they are provided', () => {
+    const annotation = makeSorted([['fish', 0.9]]);
+    const enabledTracks: Ref<AnnotationWithContext<Track>[]> = ref([{
+      annotation,
+      context: { confidencePairIndex: 0 },
+    }]);
+    const getTrackProjection = vi.fn();
+    const { eventChartData } = useEventChart({
+      enabledTracks,
+      selectedTrackIds: ref([7]),
+      typeStyling,
+      getTrackProjection,
+      timelineRange: () => [4, 10],
+      timelineFeatures: () => [{ frame: 4, keyframe: true, interpolate: false }],
+    });
+
+    expect(eventChartData.value.values[0]).toEqual(expect.objectContaining({
+      range: [4, 10],
+      markers: [[4, false]],
+    }));
+    expect(getTrackProjection).not.toHaveBeenCalled();
+  });
+});
diff --git a/client/src/use/useEventChart.ts b/client/src/use/useEventChart.ts
index 8e9240dba..ccba0437f 100644
--- a/client/src/use/useEventChart.ts
+++ b/client/src/use/useEventChart.ts
@@ -11,6 +11,15 @@ interface EventChartParams<T extends BaseAnnotation> {
   selectedTrackIds: Ref<AnnotationId[]>;
   typeStyling: Ref<TypeStyling>;
   getTrackProjection: (id: AnnotationId) => TrackProjection;
+  /** Range and features on the playback timeline, when it differs from the stored frames. */
+  timelineRange?: (id: AnnotationId) => [number, number] | null;
+  timelineFeatures?: (id: AnnotationId) => TimelineFeature[] | null;
+}
+
+export interface TimelineFeature {
+  frame: number;
+  keyframe: boolean;
+  interpolate: boolean;
 }
 
 export interface EventChartData {
@@ -24,7 +33,7 @@ export interface EventChartData {
 }
 
 export default function useEventChart<T extends BaseAnnotation>({
-  enabledTracks, selectedTrackIds, typeStyling, getTrackProjection,
+  enabledTracks, selectedTrackIds, typeStyling, getTrackProjection, timelineRange, timelineFeatures,
 }: EventChartParams<T>) {
   const eventChartData = computed(() => {
     const values = [] as EventChartData[];
@@ -36,9 +45,14 @@ export default function useEventChart<T extends BaseAnnotation>({
       const { confidencePairs } = track;
       let markers: [number, boolean][] = [];
       if (selectedTrackIds.value.includes(filtered.annotation.id)) {
-        const projection = getTrackProjection(filtered.annotation.id);
-        markers = projection.featureIndex.map((i) => (
-          [i, projection.features[i]?.interpolate || false]));
+        const onTimeline = timelineFeatures?.(filtered.annotation.id);
+        if (onTimeline) {
+          markers = onTimeline.map((feature) => [feature.frame, feature.interpolate]);
+        } else {
+          const projection = getTrackProjection(filtered.annotation.id);
+          markers = projection.featureIndex.map((i) => (
+            [i, projection.features[i]?.interpolate || false]));
+        }
       }
       if (confidencePairs.length) {
         const trackType = track.getType(filtered.context.confidencePairIndex);
@@ -48,7 +62,7 @@ export default function useEventChart<T extends BaseAnnotation>({
           type: trackType,
           color: mapfunc(trackType),
           selected: selectedTrackIdsValue.includes(track.id),
-          range: [track.begin, track.end],
+          range: timelineRange?.(track.id) ?? [track.begin, track.end],
           markers,
         });
       }
diff --git a/client/src/use/useLineChart.spec.ts b/client/src/use/useLineChart.spec.ts
index 317be1ac8..8ccbfca01 100644
--- a/client/src/use/useLineChart.spec.ts
+++ b/client/src/use/useLineChart.spec.ts
@@ -74,3 +74,35 @@ describe('useLineChart display context', () => {
       .toEqual([[0, 0]]);
   });
 });
+
+describe('useLineChart on an aligned timeline', () => {
+  afterEach(() => {
+    clientSettings.timelineCountSettings.defaultView = 'tracks';
+  });
+
+  it.each(['tracks', 'detections'] as const)('counts %s at timeline slots when they are provided', (view) => {
+    clientSettings.timelineCountSettings.defaultView = view;
+    clientSettings.timelineCountSettings.totalCount = false;
+    const enabledTracks: Ref<TrackWithContext[]> = ref([{
+      annotation: makeSorted([['fish', 0.9]]),
+      context: { confidencePairIndex: 0 },
+    }]);
+    const getTrackProjection = vi.fn();
+    const { lineChartData } = useLineChart({
+      enabledTracks,
+      allTypes: ref(['fish']),
+      typeStyling,
+      getTrackProjection,
+      timelineRange: () => [4, 10],
+      timelineFeatures: () => [
+        { frame: 4, keyframe: true, interpolate: false },
+        { frame: 10, keyframe: true, interpolate: false },
+      ],
+    });
+
+    const fish = lineChartData.value.find(({ name }) => name === 'fish');
+    expect(fish?.values).toEqual(expect.arrayContaining([[4, 1]]));
+    expect(fish?.values).not.toEqual(expect.arrayContaining([[3, 1]]));
+    expect(getTrackProjection).not.toHaveBeenCalled();
+  });
+});
diff --git a/client/src/use/useLineChart.ts b/client/src/use/useLineChart.ts
index eb539225e..59316a601 100644
--- a/client/src/use/useLineChart.ts
+++ b/client/src/use/useLineChart.ts
@@ -4,13 +4,16 @@ import { AnnotationId } from 'vue-media-annotator/BaseAnnotation';
 import type { TrackProjection } from 'vue-media-annotator/TrackProjection';
 import type { TrackWithContext } from '../BaseFilterControls';
 import type { TypeStyling } from '../StyleManager';
+import type { TimelineFeature } from './useEventChart';
 
 interface UseLineChartParams {
   enabledTracks: Readonly<Ref<readonly TrackWithContext[]>>;
   typeStyling: Ref<TypeStyling>;
   allTypes: Readonly<Ref<readonly string[]>>;
   getTrackProjection: (id: AnnotationId) => TrackProjection;
-
+  /** Range and features on the playback timeline, when it differs from the stored frames. */
+  timelineRange?: (id: AnnotationId) => [number, number] | null;
+  timelineFeatures?: (id: AnnotationId) => TimelineFeature[] | null;
 }
 
 export interface LineChartData {
@@ -56,6 +59,8 @@ export default function useLineChart({
   typeStyling,
   allTypes,
   getTrackProjection,
+  timelineRange,
+  timelineFeatures,
 }: UseLineChartParams) {
   const lineChartData = computed(() => {
     /* Histogram map contains multiple histograms keyed
@@ -74,10 +79,12 @@ export default function useLineChart({
     enabledTracks.value.forEach((filtered) => {
       const { annotation: track } = filtered;
       if (clientSettings.timelineCountSettings.defaultView === 'detections') {
-        const trackObj = getTrackProjection(track.id);
-        const frames = trackObj.features
-          .filter((item) => item?.keyframe)
-          .map((item) => item?.frame as number);
+        const onTimeline = timelineFeatures?.(track.id);
+        const frames = onTimeline
+          ? onTimeline.filter((feature) => feature.keyframe).map((feature) => feature.frame)
+          : getTrackProjection(track.id).features
+            .filter((item) => item?.keyframe)
+            .map((item) => item?.frame as number);
         const segments = framesToSegments(frames);
         segments.forEach((segment) => {
           const ibegin = segment[0];
@@ -91,8 +98,9 @@ export default function useLineChart({
           [typeArr[ibegin], typeArr[iend]] = updateHistogram(ibegin, iend, typeArr);
         });
       } else {
-        const ibegin = track.begin;
-        const iend = track.end > track.begin ? track.end : track.begin + 1;
+        const [begin, end] = timelineRange?.(track.id) ?? [track.begin, track.end];
+        const ibegin = begin;
+        const iend = end > begin ? end : begin + 1;
 
         if (clientSettings.timelineCountSettings.totalCount) {
           const totalArr = histograms.get('total') as number[];
diff --git a/server/dive_server/crud_annotation.py b/server/dive_server/crud_annotation.py
index a4a12f482..ba5c303cc 100644
--- a/server/dive_server/crud_annotation.py
+++ b/server/dive_server/crud_annotation.py
@@ -482,3 +482,109 @@ def get_labels(user: types.GirderUserModel, published=False, shared=False):
         {'$sort': {'_id': 1}},
     ]
     return Folder().collection.aggregate(pipeline)
+
+
+def shift_track_frames(track: dict, delta: int) -> Optional[dict]:
+    """Move every feature of a serialized track by ``delta`` frames.
+
+    Features that would land before frame 0 are dropped, and begin/end are
+    recomputed from what survives so the Track validator's bounds check still
+    holds. Returns None when nothing survives.
+    """
+    if delta == 0:
+        return track
+    features = [
+        {**feature, 'frame': feature['frame'] + delta}
+        for feature in track.get('features', [])
+        if feature['frame'] + delta >= 0
+    ]
+    if not features:
+        return None
+    return {
+        **track,
+        'features': features,
+        'begin': features[0]['frame'],
+        'end': features[-1]['frame'],
+    }
+
+
+def shift_group_frames(group: dict, delta: int) -> Optional[dict]:
+    """Move every member range of a serialized group by ``delta`` frames.
+
+    Ranges ending before frame 0 are dropped, ranges straddling it are
+    clipped, and members left with no range are removed. Returns None when
+    no member survives.
+    """
+    if delta == 0:
+        return group
+    members = {}
+    for member_id, member in group.get('members', {}).items():
+        ranges = [
+            [max(0, begin + delta), end + delta]
+            for begin, end in member.get('ranges', [])
+            if end + delta >= 0
+        ]
+        if ranges:
+            members[member_id] = {**member, 'ranges': ranges}
+    if not members:
+        return None
+    all_ranges = [r for member in members.values() for r in member['ranges']]
+    return {
+        **group,
+        'members': members,
+        'begin': min(r[0] for r in all_ranges),
+        'end': max(r[1] for r in all_ranges),
+    }
+
+
+def shift_annotation_frames(
+    dsFolder: types.GirderModel,
+    user: types.GirderUserModel,
+    delta: int,
+) -> dict:
+    """Move every annotation in a dataset, across all of its sets, by ``delta`` frames.
+
+    Written as one new revision per set through save_annotations, so the
+    move is undoable with rollback like any other edit. Every set is shifted
+    because they all annotate the same media: leaving one behind would put
+    it out of step with the video it describes.
+    """
+    counts = {'tracks': 0, 'groups': 0, 'dropped': 0}
+    if delta == 0:
+        return counts
+    sets: List[Optional[str]] = [None]
+    sets.extend(s for s in RevisionLogItem().sets(dsFolder) if s)
+    description = f'shift frames by {delta:+d}'
+    for annotation_set in sets:
+        upsert_tracks: List[dict] = []
+        delete_tracks: List[int] = []
+        for track in TrackItem().list(dsFolder, set=annotation_set):
+            shifted = shift_track_frames(track, delta)
+            if shifted is None:
+                delete_tracks.append(track[IDENTIFIER])
+            else:
+                upsert_tracks.append(shifted)
+        upsert_groups: List[dict] = []
+        delete_groups: List[int] = []
+        for group in GroupItem().list(dsFolder, set=annotation_set):
+            shifted = shift_group_frames(group, delta)
+            if shifted is None:
+                delete_groups.append(group[IDENTIFIER])
+            else:
+                upsert_groups.append(shifted)
+        if not (upsert_tracks or delete_tracks or upsert_groups or delete_groups):
+            continue
+        save_annotations(
+            dsFolder,
+            user,
+            upsert_tracks=upsert_tracks,
+            delete_tracks=delete_tracks,
+            upsert_groups=upsert_groups,
+            delete_groups=delete_groups,
+            description=description,
+            set=annotation_set or '',
+        )
+        counts['tracks'] += len(upsert_tracks)
+        counts['groups'] += len(upsert_groups)
+        counts['dropped'] += len(delete_tracks) + len(delete_groups)
+    return counts
diff --git a/server/dive_server/crud_dataset.py b/server/dive_server/crud_dataset.py
index 99484cf2c..aee42ad7e 100644
--- a/server/dive_server/crud_dataset.py
+++ b/server/dive_server/crud_dataset.py
@@ -2163,3 +2163,41 @@ def set_metadata_file(
         'metadataFileItemId': str(md_item['_id']),
         'metadataFileOriginalName': md_item['name'],
     }
+
+
+def apply_camera_frame_offset(
+    parent: types.GirderModel,
+    user: types.GirderUserModel,
+    camera: str,
+    offset: int,
+) -> dict:
+    """Bring one camera's stored annotations onto its time offset.
+
+    The offset is the camera's start offset in its own frames (see the
+    client's alignedTimeline.buildOffsetTimeline). Only the part not yet
+    applied to the annotations is shifted, and the offset plus its applied
+    record are written together afterwards, so a failed shift never leaves
+    the record ahead of the data.
+    """
+    crud.verify_dataset(parent)
+    if fromMeta(parent, constants.TypeMarker) != constants.MultiType:
+        raise RestException('Time offsets apply to multicamera datasets only', code=400)
+    multi_cam = fromMeta(parent, constants.MultiCamMarker) or {}
+    cam_info = (multi_cam.get('cameras') or {}).get(camera)
+    if not cam_info:
+        raise RestException(f'Unknown camera "{camera}"', code=400)
+    child = Folder().load(cam_info['folderId'], level=AccessType.WRITE, user=user)
+    if child is None:
+        raise RestException(f'Camera folder for "{camera}" was not found', code=404)
+    offsets = dict(fromMeta(parent, 'cameraFrameOffsets', {}) or {})
+    applied = dict(fromMeta(parent, 'cameraFrameOffsetsApplied', {}) or {})
+    delta = offset - applied.get(camera, 0)
+    counts = crud_annotation.shift_annotation_frames(child, user, delta)
+    offsets[camera] = offset
+    applied[camera] = offset
+    update_metadata(
+        parent,
+        {'cameraFrameOffsets': offsets, 'cameraFrameOffsetsApplied': applied},
+        verify=False,
+    )
+    return {'camera': camera, 'offset': offset, 'delta': delta, **counts}
diff --git a/server/dive_server/views_dataset.py b/server/dive_server/views_dataset.py
index e71e558d9..db857a9b3 100644
--- a/server/dive_server/views_dataset.py
+++ b/server/dive_server/views_dataset.py
@@ -61,6 +61,7 @@ def __init__(self, resourceName):
         self.route("POST", ("validate_files",), self.validate_files)
 
         self.route("PATCH", (":id",), self.patch_metadata)
+        self.route("PATCH", (":id", "camera_frame_offset"), self.apply_camera_frame_offset)
 
         # do we make this another resource in girder?
         self.route("PATCH", (":id", "attributes"), self.patch_attributes)
@@ -469,6 +470,26 @@ def patch_metadata(self, folder, data):
         crud_dataset.remove_camera_type_hierarchy(folder)
         return result
 
+    @access.user
+    @autoDescribeRoute(
+        Description("Shift one camera's annotations onto its time offset")
+        .modelParam("id", level=AccessType.WRITE, **DatasetModelParam)
+        .jsonParam(
+            "data",
+            description="{camera: string, offset: integer frames}",
+            requireObject=True,
+            paramType="body",
+        )
+    )
+    def apply_camera_frame_offset(self, folder, data):
+        camera = data.get('camera')
+        offset = data.get('offset')
+        if not isinstance(camera, str) or not camera:
+            raise RestException('"camera" must be a camera name', code=400)
+        if isinstance(offset, bool) or not isinstance(offset, int):
+            raise RestException('"offset" must be a whole number of frames', code=400)
+        return crud_dataset.apply_camera_frame_offset(folder, self.getCurrentUser(), camera, offset)
+
     @access.user
     @autoDescribeRoute(
         Description("Update set of possible attributes")
diff --git a/server/dive_tasks/convert_video.py b/server/dive_tasks/convert_video.py
index 1cd7937ac..842147d4b 100644
--- a/server/dive_tasks/convert_video.py
+++ b/server/dive_tasks/convert_video.py
@@ -231,6 +231,9 @@ def convert_video(
             # see native/<platform> code for a discussion of this option
             "-vf",
             "scale=ceil(iw*sar/2)*2:ceil(ih/2)*2,setsar=1",
+            # Put the index up front so a browser can start playing before the file is down.
+            "-movflags",
+            "+faststart",
             str(output_file_path),
         ]
         utils.stream_subprocess(self, context, manager, {'args': command})
diff --git a/server/dive_tasks/multicam_pipeline.py b/server/dive_tasks/multicam_pipeline.py
index 72d870c5e..4e8ab9586 100644
--- a/server/dive_tasks/multicam_pipeline.py
+++ b/server/dive_tasks/multicam_pipeline.py
@@ -255,7 +255,7 @@ def build_registration_pairs(folder_meta: dict) -> List[dict]:
     become the file's imageLeft/imageRight, and each point's a/b pair becomes
     one `leftX leftY rightX rightY` row.
 
-    VIAME's dive transform reader only consumes the matrices; the
+    VIAME's homography_json transform reader only consumes the matrices; the
     observations travel for provenance and so a file round-trips back into
     DIVE without losing which frame contributed what.
     """
@@ -387,12 +387,147 @@ def build_registration_kwiver_settings(
             )
         warp = f'warp{index + 1}'
         settings[f'{warp}:transformation_file'] = str(registration_path)
-        settings[f'{warp}:transform_reader:type'] = 'dive'
-        settings[f'{warp}:transform_reader:dive:from_camera'] = name
-        settings[f'{warp}:transform_reader:dive:to_camera'] = reference
+        settings[f'{warp}:transform_reader:type'] = 'homography_json'
+        settings[f'{warp}:transform_reader:homography_json:from_camera'] = name
+        settings[f'{warp}:transform_reader:homography_json:to_camera'] = reference
     return settings
 
 
+def video_frame_count(folder_meta: dict) -> Optional[int]:
+    """Native frame count of a video camera from its folder metadata, or None."""
+    info = folder_meta.get('ffprobe_info') or {}
+    try:
+        nb_frames = int(info.get('nb_frames') or 0)
+    except (TypeError, ValueError):
+        nb_frames = 0
+    if nb_frames > 0:
+        return nb_frames
+    try:
+        duration = float(info.get('duration') or 0)
+        fps = float(folder_meta.get(constants.OriginalFPSMarker) or 0)
+    except (TypeError, ValueError):
+        return None
+    if duration > 0 and fps > 0:
+        return int(round(duration * fps))
+    return None
+
+
+def common_frame_bound(
+    camera_media: Dict[str, Tuple[List[str], str]],
+    image_pairs: Optional[Dict[str, List[str]]],
+    frame_counts: Dict[str, int],
+) -> Optional[int]:
+    """
+    Frame count every camera must be cut to so the lockstep pipe ends together.
+
+    Returns None when the cameras already agree or no count is known. Video
+    cameras without a frame subset take their count from frame_counts.
+    """
+    counts: List[int] = []
+    for name, (media_list, media_type) in camera_media.items():
+        subset = (image_pairs or {}).get(name)
+        if subset is not None:
+            counts.append(len(subset))
+        elif media_type == constants.VideoType:
+            if name in frame_counts:
+                counts.append(frame_counts[name])
+        else:
+            counts.append(len(media_list))
+    if len(counts) < 2 or min(counts) == max(counts):
+        return None
+    return min(counts)
+
+
+def paired_start_frames(
+    frame_counts: Dict[str, int],
+    offsets: Optional[Dict[str, int]],
+) -> Optional[Tuple[Dict[str, int], int]]:
+    """
+    Per-camera start index and common length from the dataset's camera time offsets.
+
+    offsets[name] is the frame of that camera that coincides with frame 0 of a
+    camera at offset 0. Returns None when no camera is offset; the length is
+    <= 0 when the offsets leave no overlapping span.
+    """
+    names = list(frame_counts)
+    if not offsets or not any(offsets.get(name, 0) for name in names):
+        return None
+    first_slot = max(-offsets.get(name, 0) for name in names)
+    start = {name: first_slot + offsets.get(name, 0) for name in names}
+    spans = [frame_counts[name] - start[name] for name in names if frame_counts[name] > 0]
+    return start, (min(spans) if spans else 0)
+
+
+def camera_frame_size(
+    folder_meta: dict, media_list: List[str], media_type: str
+) -> Optional[Tuple[int, int]]:
+    """Pixel size of a camera's frames: ffprobe metadata for video, the first image otherwise."""
+    if media_type == constants.VideoType:
+        info = folder_meta.get('ffprobe_info') or {}
+        try:
+            width, height = int(info.get('width') or 0), int(info.get('height') or 0)
+        except (TypeError, ValueError):
+            return None
+        return (width, height) if width > 0 and height > 0 else None
+    if not media_list:
+        return None
+    try:
+        from PIL import Image
+
+        with Image.open(media_list[0]) as image:
+            return image.size
+    except Exception:
+        return None
+
+
+def _csv_number(value: float) -> str:
+    return str(int(round(value))) if value == round(value) else f'{value:.3f}'
+
+
+def clip_viame_csv_to_frame(
+    csv_path: str, width: int, height: int, min_visible: float = 0.25
+) -> Tuple[str, int, int]:
+    """
+    Clip every box in a VIAME CSV to the frame and drop boxes mostly outside it.
+
+    A box keeps its row when at least min_visible of its area lies inside the
+    width x height frame (a zero-area box must lie inside); the surviving box
+    is clamped to the frame edges. Returns (output path, boxes clipped, rows dropped).
+    """
+    output_path = csv_path.replace('.csv', '_clipped.csv')
+    clipped = 0
+    dropped = 0
+    with (
+        open(csv_path, 'r', encoding='utf-8') as infile,
+        open(output_path, 'w', encoding='utf-8') as outfile,
+    ):
+        for line in infile:
+            parts = line.rstrip('\r\n').split(',')
+            if line.startswith('#') or len(parts) < 7:
+                outfile.write(line)
+                continue
+            try:
+                x0, y0, x1, y1 = (float(value) for value in parts[3:7])
+            except ValueError:
+                outfile.write(line)
+                continue
+            cx0, cy0 = min(max(x0, 0.0), width), min(max(y0, 0.0), height)
+            cx1, cy1 = min(max(x1, 0.0), width), min(max(y1, 0.0), height)
+            area = max(0.0, x1 - x0) * max(0.0, y1 - y0)
+            inside = max(0.0, cx1 - cx0) * max(0.0, cy1 - cy0)
+            visible = inside / area if area > 0 else float((cx0, cy0, cx1, cy1) == (x0, y0, x1, y1))
+            if visible < min_visible:
+                dropped += 1
+                continue
+            if (cx0, cy0, cx1, cy1) != (x0, y0, x1, y1):
+                parts[3:7] = [_csv_number(v) for v in (cx0, cy0, cx1, cy1)]
+                clipped += 1
+                outfile.write(','.join(parts) + '\n')
+            else:
+                outfile.write(line)
+    return output_path, clipped, dropped
+
+
 def build_multicam_kwiver_settings(
     work_dir: Path,
     cameras: List[MulticamCameraJob],
@@ -402,6 +537,8 @@ def build_multicam_kwiver_settings(
     image_pairs: Optional[Dict[str, List[str]]] = None,
     fps: Optional[float] = None,
     on_progress: Optional[Callable[[str], None]] = None,
+    frame_bound: Optional[int] = None,
+    frame_starts: Optional[Dict[str, int]] = None,
 ) -> Tuple[Dict[str, str], Dict[str, str]]:
     """
     Build KWIVER -s key/value pairs for per-camera inputs/outputs.
@@ -415,6 +552,10 @@ def build_multicam_kwiver_settings(
     must then drop any video reader type it would otherwise set (see
     video_subset_cameras).
 
+    frame_starts skips each camera to its first paired frame (see
+    paired_start_frames) and frame_bound caps every camera at that many frames
+    from there: image lists are sliced, video readers get start/stop frames.
+
     Returns (arg_file_pair, out_files) where out_files maps camera name -> output csv basename.
     """
     arg_file_pair: Dict[str, str] = {}
@@ -480,7 +621,11 @@ def camera_progress(done: int, total: int, name: str = key) -> None:
             arg_file_pair['detector_writer:file_name'] = output_file_name
             arg_file_pair['track_writer:file_name'] = output_file_name
 
+        first = (frame_starts or {}).get(key, 0) if not extracted_subset else 0
         if media_type in constants.ImageListTypes or extracted_subset:
+            if first or frame_bound is not None:
+                stop = None if frame_bound is None else first + frame_bound
+                media_list = media_list[first:stop]
             input_file_name = str(work_dir / f'input{i + 1}_images.txt')
             with open(input_file_name, 'w', encoding='utf-8') as img_list_file:
                 img_list_file.write('\n'.join(media_list))
@@ -490,6 +635,12 @@ def camera_progress(done: int, total: int, name: str = key) -> None:
         elif media_type == constants.VideoType:
             assert len(media_list) == 1, 'Expected exactly one video per camera'
             arg_file_pair[f'input{i + 1}:video_reader:type'] = 'vidl_ffmpeg'
+            reader = f'input{i + 1}:video_reader:vidl_ffmpeg'
+            if first:
+                # vidl_ffmpeg frames are 1-based; 0 means unset.
+                arg_file_pair[f'{reader}:start_at_frame'] = str(first + 1)
+            if frame_bound is not None:
+                arg_file_pair[f'{reader}:stop_after_frame'] = str(first + frame_bound)
             arg_file_pair[input_arg] = media_list[0]
             if i == 0:
                 arg_file_pair['input:video_filename'] = media_list[0]
diff --git a/server/dive_tasks/run_pipeline.py b/server/dive_tasks/run_pipeline.py
index c9d98946b..aeb0c0aca 100644
--- a/server/dive_tasks/run_pipeline.py
+++ b/server/dive_tasks/run_pipeline.py
@@ -18,8 +18,13 @@
     append_stereo_calibration_kwiver_settings,
     build_multicam_kwiver_settings,
     build_registration_kwiver_settings,
+    camera_frame_size,
+    clip_viame_csv_to_frame,
+    common_frame_bound,
     find_downloaded_calibration_file,
     is_stereo_measurement_pipeline,
+    paired_start_frames,
+    video_frame_count,
     video_subset_cameras,
 )
 from dive_tasks.pipeline_creates_dataset import (
@@ -328,6 +333,40 @@ def report_extraction(message: str) -> None:
                     raise utils.CanceledError('Job was canceled')
                 manager.write(f'{message}\n')
 
+            # Cut every camera to the shortest so the lockstep pipe ends together.
+            frame_counts: Dict[str, int] = {}
+            for camera in multicam_cameras:
+                media_list, media_type = camera_media[camera['name']]
+                if media_type != constants.VideoType:
+                    frame_counts[camera['name']] = len(media_list)
+                    continue
+                count = video_frame_count(gc.getFolder(camera['folder_id']).get('meta') or {})
+                if count is not None:
+                    frame_counts[camera['name']] = count
+            frame_starts: Optional[Dict[str, int]] = None
+            frame_bound: Optional[int] = None
+            # A frame subset already pairs row for row, so offsets apply only to full runs.
+            offsets = None if image_pairs else fromMeta(input_folder, 'cameraFrameOffsets', None)
+            span = paired_start_frames(frame_counts, offsets)
+            if span is not None:
+                frame_starts, frame_bound = span
+                if frame_bound <= 0:
+                    raise ValueError(
+                        'The camera time offsets leave no overlapping frames between cameras; '
+                        'check the Time Offset in the Camera Registration panel.'
+                    )
+                skipped = ', '.join(f'{k} from frame {v}' for k, v in frame_starts.items() if v)
+                manager.write(
+                    f'Applying camera time offsets ({skipped}); running {frame_bound} frames\n'
+                )
+            else:
+                frame_bound = common_frame_bound(camera_media, image_pairs, frame_counts)
+                if frame_bound is not None:
+                    manager.write(
+                        'Cameras differ in length; '
+                        f'running the first {frame_bound} frames of each\n'
+                    )
+
             arg_file_pair, out_files = build_multicam_kwiver_settings(
                 _working_directory_path,
                 multicam_cameras,
@@ -336,6 +375,8 @@ def report_extraction(message: str) -> None:
                 image_pairs=image_pairs,
                 fps=input_fps,
                 on_progress=report_extraction if extracted_cameras else None,
+                frame_bound=frame_bound,
+                frame_starts=frame_starts,
             )
 
             command = [
@@ -522,6 +563,25 @@ def report_extraction(message: str) -> None:
                 if frame_range is not None and camera_media[cam_name][1] == constants.VideoType:
                     filtered_path = filter_csv_by_frame_range(str(output_file), frame_range)
                     output_file = Path(filtered_path)
+                if multicam_registration and output_file.exists():
+                    # Warped boxes can land outside the target camera's field of view.
+                    media_list, media_type = camera_media[cam_name]
+                    size = camera_frame_size(
+                        gc.getFolder(camera['folder_id']).get('meta') or {}, media_list, media_type
+                    )
+                    if size is None:
+                        manager.write(
+                            f'Warning: unknown frame size for {cam_name}; boxes not clipped\n'
+                        )
+                    else:
+                        clipped_path, clipped, dropped = clip_viame_csv_to_frame(
+                            str(output_file), size[0], size[1]
+                        )
+                        output_file = Path(clipped_path)
+                        manager.write(
+                            f'{cam_name}: clipped {clipped} box(es) to the {size[0]}x{size[1]} '
+                            f'frame and dropped {dropped} outside it\n'
+                        )
                 newfile = gc.uploadFileToFolder(camera['folder_id'], str(output_file))
                 gc.addMetadataToItem(str(newfile["itemId"]), {"pipeline": pipeline})
                 gc.post(
diff --git a/server/dive_tasks/viame_config.py b/server/dive_tasks/viame_config.py
index a09489bcf..f3ea4602a 100644
--- a/server/dive_tasks/viame_config.py
+++ b/server/dive_tasks/viame_config.py
@@ -32,8 +32,10 @@ def get_gpu_environment() -> Dict[str, str]:
     env["PATH"] = env.get("PATH").replace("/opt/dive/local/venv/bin", "")
     # VIAME ships its own python, and kwiver prepends $VIRTUAL_ENV's
     # site-packages to the embedded interpreter's sys.path, so leaving this set
-    # points VIAME at our venv (a different python version).
-    env.pop("VIRTUAL_ENV", None)
+    # points VIAME at our venv (a different python version). `uv run` also
+    # re-exports its UV_PYTHON* selection; drop those for the same reason.
+    for key in ("VIRTUAL_ENV", "UV_PYTHON", "UV_PYTHON_INSTALL_DIR"):
+        env.pop(key, None)
     return env
 
 
diff --git a/server/dive_utils/models.py b/server/dive_utils/models.py
index d0139c7b7..fea62c721 100644
--- a/server/dive_utils/models.py
+++ b/server/dive_utils/models.py
@@ -305,6 +305,10 @@ class MetadataMutable(BaseModel):
     # and image names and editable afterwards; used to place cameras onto a
     # pipeline's declared camera slots. Cameras with no known role are absent.
     cameraRoles: Optional[Dict[str, CameraRole]]
+    # Per-camera start offset in its own frames, for recorders that started at different times.
+    cameraFrameOffsets: Optional[Dict[str, int]]
+    # The part of cameraFrameOffsets already applied to each camera's annotations.
+    cameraFrameOffsetsApplied: Optional[Dict[str, int]]
     fps: Optional[float]
 
     @staticmethod
diff --git a/server/tests/test_camera_frame_offset.py b/server/tests/test_camera_frame_offset.py
new file mode 100644
index 000000000..5e7321d6f
--- /dev/null
+++ b/server/tests/test_camera_frame_offset.py
@@ -0,0 +1,161 @@
+from unittest.mock import patch
+
+from girder.exceptions import RestException
+import pytest
+
+from dive_server import crud_annotation, crud_dataset
+from dive_server.crud_annotation import IDENTIFIER
+from dive_utils import constants
+
+
+def _track(track_id, frames):
+    return {
+        'id': track_id,
+        'begin': frames[0],
+        'end': frames[-1],
+        'confidencePairs': [['fish', 1.0]],
+        'attributes': {},
+        'features': [{'frame': frame, 'bounds': [0, 0, 1, 1]} for frame in frames],
+    }
+
+
+class TestShiftTrackFrames:
+    def test_moves_features_and_bounds(self):
+        shifted = crud_annotation.shift_track_frames(_track(1, [3, 4, 5]), 9)
+        assert [f['frame'] for f in shifted['features']] == [12, 13, 14]
+        assert (shifted['begin'], shifted['end']) == (12, 14)
+
+    def test_drops_features_before_frame_zero(self):
+        shifted = crud_annotation.shift_track_frames(_track(1, [3, 4, 5]), -4)
+        assert [f['frame'] for f in shifted['features']] == [0, 1]
+        assert (shifted['begin'], shifted['end']) == (0, 1)
+
+    def test_rebounds_to_the_first_surviving_feature(self):
+        # A gap after the dropped feature: begin follows the data, not a clamp to 0.
+        shifted = crud_annotation.shift_track_frames(_track(1, [3, 10]), -5)
+        assert [f['frame'] for f in shifted['features']] == [5]
+        assert (shifted['begin'], shifted['end']) == (5, 5)
+
+    def test_none_when_nothing_survives(self):
+        assert crud_annotation.shift_track_frames(_track(1, [0, 1]), -5) is None
+
+    def test_identity_at_zero(self):
+        track = _track(1, [1])
+        assert crud_annotation.shift_track_frames(track, 0) is track
+
+
+class TestShiftGroupFrames:
+    def test_moves_and_clips_member_ranges(self):
+        group = {
+            'id': 1,
+            'begin': 2,
+            'end': 20,
+            'members': {'1': {'ranges': [[2, 6], [10, 20]]}, '2': {'ranges': [[0, 1]]}},
+        }
+        shifted = crud_annotation.shift_group_frames(group, -4)
+        assert shifted['members'] == {'1': {'ranges': [[0, 2], [6, 16]]}}
+        assert (shifted['begin'], shifted['end']) == (0, 16)
+
+    def test_none_when_no_member_survives(self):
+        group = {'id': 1, 'begin': 0, 'end': 1, 'members': {'1': {'ranges': [[0, 1]]}}}
+        assert crud_annotation.shift_group_frames(group, -2) is None
+
+
+@patch('dive_server.crud_annotation.save_annotations')
+@patch('dive_server.crud_annotation.GroupItem')
+@patch('dive_server.crud_annotation.TrackItem')
+@patch('dive_server.crud_annotation.RevisionLogItem')
+def test_shift_annotation_frames_writes_every_set(revision_log, track_item, group_item, save):
+    folder = {'_id': 'camera-id'}
+    revision_log.return_value.sets.return_value = [None, 'review']
+    track_item.return_value.list.side_effect = lambda _f, set=None: [
+        _track(1, [3, 4]),
+        _track(2, [0]),
+    ]
+    group_item.return_value.list.return_value = []
+
+    counts = crud_annotation.shift_annotation_frames(folder, {'login': 'u'}, -2)
+
+    assert counts == {'tracks': 2, 'groups': 0, 'dropped': 2}
+    assert save.call_count == 2
+    assert [call.kwargs['set'] for call in save.call_args_list] == ['', 'review']
+    first = save.call_args_list[0].kwargs
+    assert [t[IDENTIFIER] for t in first['upsert_tracks']] == [1]
+    assert first['upsert_tracks'][0]['begin'] == 1
+    assert first['delete_tracks'] == [2]
+    assert first['description'] == 'shift frames by -2'
+
+
+@patch('dive_server.crud_annotation.save_annotations')
+@patch('dive_server.crud_annotation.TrackItem')
+def test_shift_annotation_frames_is_a_no_op_at_zero(track_item, save):
+    counts = crud_annotation.shift_annotation_frames({'_id': 'x'}, {'login': 'u'}, 0)
+    assert counts == {'tracks': 0, 'groups': 0, 'dropped': 0}
+    track_item.return_value.list.assert_not_called()
+    save.assert_not_called()
+
+
+def _multi_parent(applied=None):
+    return {
+        '_id': 'parent-id',
+        'meta': {
+            'annotate': True,
+            'type': constants.MultiType,
+            'fps': 5,
+            'multiCam': {
+                'defaultDisplay': 'EO',
+                'cameras': {
+                    'EO': {'folderId': 'eo-id', 'type': 'video'},
+                    'IR': {'folderId': 'ir-id', 'type': 'video'},
+                },
+            },
+            **({'cameraFrameOffsetsApplied': applied} if applied else {}),
+        },
+    }
+
+
+@patch('dive_server.crud_dataset.update_metadata')
+@patch('dive_server.crud_dataset.crud_annotation.shift_annotation_frames')
+@patch('dive_server.crud_dataset.Folder')
+def test_apply_camera_frame_offset_shifts_only_the_unapplied_part(folder_cls, shift, update):
+    parent = _multi_parent(applied={'IR': 4})
+    child = {'_id': 'ir-id'}
+    folder_cls.return_value.load.return_value = child
+    shift.return_value = {'tracks': 3, 'groups': 0, 'dropped': 1}
+    user = {'login': 'u'}
+
+    result = crud_dataset.apply_camera_frame_offset(parent, user, 'IR', 9)
+
+    shift.assert_called_once_with(child, user, 5)
+    update.assert_called_once_with(
+        parent,
+        {'cameraFrameOffsets': {'IR': 9}, 'cameraFrameOffsetsApplied': {'IR': 9}},
+        verify=False,
+    )
+    assert result == {
+        'camera': 'IR',
+        'offset': 9,
+        'delta': 5,
+        'tracks': 3,
+        'groups': 0,
+        'dropped': 1,
+    }
+
+
+@patch('dive_server.crud_dataset.update_metadata')
+@patch('dive_server.crud_dataset.crud_annotation.shift_annotation_frames')
+@patch('dive_server.crud_dataset.Folder')
+def test_apply_camera_frame_offset_rejects_unknown_camera(folder_cls, shift, update):
+    with pytest.raises(RestException):
+        crud_dataset.apply_camera_frame_offset(_multi_parent(), {'login': 'u'}, 'UV', 1)
+    shift.assert_not_called()
+    update.assert_not_called()
+
+
+@patch('dive_server.crud_dataset.update_metadata')
+@patch('dive_server.crud_dataset.crud_annotation.shift_annotation_frames')
+def test_apply_camera_frame_offset_rejects_single_camera_dataset(shift, update):
+    folder = {'_id': 'x', 'meta': {'annotate': True, 'type': constants.VideoType, 'fps': 5}}
+    with pytest.raises(RestException):
+        crud_dataset.apply_camera_frame_offset(folder, {'login': 'u'}, 'EO', 1)
+    shift.assert_not_called()
diff --git a/server/tests/test_multicam_pipeline.py b/server/tests/test_multicam_pipeline.py
index 581ce8bf0..4d250086f 100644
--- a/server/tests/test_multicam_pipeline.py
+++ b/server/tests/test_multicam_pipeline.py
@@ -10,15 +10,20 @@
     build_multicam_kwiver_settings,
     build_registration_kwiver_settings,
     build_registration_pairs,
+    camera_frame_size,
+    clip_viame_csv_to_frame,
+    common_frame_bound,
     find_downloaded_calibration_file,
     infer_camera_role,
     infer_camera_roles,
     is_stereo_measurement_pipeline,
     is_stereo_or_multicam_pipeline,
     missing_registrations,
+    paired_start_frames,
     pipeline_requires_input,
     pseudo_frame_number,
     stereo_calibration_keys,
+    video_frame_count,
     video_subset_cameras,
 )
 from dive_utils import constants
@@ -284,9 +289,9 @@ def test_build_registration_kwiver_settings(tmp_path: Path):
     registration_path = str(tmp_path / 'ir_to_rgb_registration.json')
     assert settings == {
         'warp2:transformation_file': registration_path,
-        'warp2:transform_reader:type': 'dive',
-        'warp2:transform_reader:dive:from_camera': 'ir',
-        'warp2:transform_reader:dive:to_camera': 'rgb',
+        'warp2:transform_reader:type': 'homography_json',
+        'warp2:transform_reader:homography_json:from_camera': 'ir',
+        'warp2:transform_reader:homography_json:to_camera': 'rgb',
     }
     written = json.loads((tmp_path / 'ir_to_rgb_registration.json').read_text(encoding='utf-8'))
     assert written['type'] == 'dive-camera-registration'
@@ -442,3 +447,110 @@ def test_build_multicam_kwiver_settings_large_image_subset(tmp_path: Path):
 
     assert (tmp_path / 'input1_images.txt').read_text(encoding='utf-8') == '/tmp/ir/001.tif'
     assert arg_pair['input:video_filename'] == str(tmp_path / 'input1_images.txt')
+
+
+def test_video_frame_count():
+    assert video_frame_count({'ffprobe_info': {'nb_frames': '300'}}) == 300
+    assert video_frame_count({'ffprobe_info': {'duration': '10.0'}, 'originalFps': 29.97}) == 300
+    assert video_frame_count({'ffprobe_info': {'duration': '10.0'}}) is None
+    assert video_frame_count({}) is None
+
+
+def test_common_frame_bound():
+    seq = constants.ImageSequenceType
+    equal = {'a': (['1', '2'], seq), 'b': (['1', '2'], seq)}
+    assert common_frame_bound(equal, None, {}) is None
+    uneven = {'a': (['1', '2', '3'], seq), 'b': (['1', '2'], seq)}
+    assert common_frame_bound(uneven, None, {}) == 2
+    videos = {'a': (['a.mp4'], constants.VideoType), 'b': (['b.mp4'], constants.VideoType)}
+    assert common_frame_bound(videos, None, {'a': 900, 'b': 850}) == 850
+    assert common_frame_bound(videos, None, {'a': 900}) is None
+    # A frame subset already pairs row for row, so its length is the count.
+    assert common_frame_bound(videos, {'a': ['frame://1'], 'b': ['frame://1']}, {'a': 9}) is None
+    mixed = {'a': (['1', '2', '3'], seq), 'b': (['b.mp4'], constants.VideoType)}
+    assert common_frame_bound(mixed, None, {'b': 2}) == 2
+
+
+def test_build_multicam_kwiver_settings_frame_bound(tmp_path: Path):
+    cameras = [
+        {'name': 'ir', 'folder_id': 'i', 'media_type': constants.ImageSequenceType},
+        {'name': 'eo', 'folder_id': 'e', 'media_type': constants.VideoType},
+    ]
+    camera_media = {
+        'ir': (['/tmp/ir/0.png', '/tmp/ir/1.png', '/tmp/ir/2.png'], constants.ImageSequenceType),
+        'eo': (['/tmp/eo.mp4'], constants.VideoType),
+    }
+    arg_pair, _ = build_multicam_kwiver_settings(tmp_path, cameras, camera_media, frame_bound=2)
+    assert (tmp_path / 'input1_images.txt').read_text(encoding='utf-8') == (
+        '/tmp/ir/0.png\n/tmp/ir/1.png'
+    )
+    assert arg_pair['input2:video_reader:vidl_ffmpeg:stop_after_frame'] == '2'
+    unbounded, _ = build_multicam_kwiver_settings(tmp_path, cameras, camera_media)
+    assert 'input2:video_reader:vidl_ffmpeg:stop_after_frame' not in unbounded
+
+
+def test_paired_start_frames():
+    assert paired_start_frames({'EO': 100, 'IR': 100}, None) is None
+    assert paired_start_frames({'EO': 100, 'IR': 100}, {'EO': 0, 'IR': 0}) is None
+    # IR frame 9 is the same instant as EO frame 0, so IR skips ahead and both stop together.
+    assert paired_start_frames({'EO': 100, 'IR': 100}, {'IR': 9}) == ({'EO': 0, 'IR': 9}, 91)
+    assert paired_start_frames({'EO': 100, 'IR': 100}, {'IR': -4}) == ({'EO': 4, 'IR': 0}, 96)
+    assert paired_start_frames({'EO': 9000, 'IR': 9008}, {'IR': 9}) == ({'EO': 0, 'IR': 9}, 8999)
+    assert paired_start_frames({'EO': 100, 'IR': 100, 'UV': 100}, {'IR': 9, 'UV': -4}) == (
+        {'EO': 4, 'IR': 13, 'UV': 0},
+        87,
+    )
+    start, length = paired_start_frames({'EO': 100, 'IR': 5}, {'IR': 9})
+    assert length <= 0
+
+
+def test_build_multicam_kwiver_settings_frame_starts(tmp_path: Path):
+    cameras = [
+        {'name': 'ir', 'folder_id': 'i', 'media_type': constants.ImageSequenceType},
+        {'name': 'eo', 'folder_id': 'e', 'media_type': constants.VideoType},
+    ]
+    camera_media = {
+        'ir': (['/tmp/ir/0.png', '/tmp/ir/1.png', '/tmp/ir/2.png'], constants.ImageSequenceType),
+        'eo': (['/tmp/eo.mp4'], constants.VideoType),
+    }
+    arg_pair, _ = build_multicam_kwiver_settings(
+        tmp_path, cameras, camera_media, frame_bound=2, frame_starts={'ir': 1, 'eo': 3}
+    )
+    assert (tmp_path / 'input1_images.txt').read_text(encoding='utf-8') == (
+        '/tmp/ir/1.png\n/tmp/ir/2.png'
+    )
+    assert arg_pair['input2:video_reader:vidl_ffmpeg:start_at_frame'] == '4'
+    assert arg_pair['input2:video_reader:vidl_ffmpeg:stop_after_frame'] == '5'
+
+
+def test_clip_viame_csv_to_frame(tmp_path: Path):
+    source = tmp_path / 'computed_tracks_IR.csv'
+    source.write_text(
+        '# metadata\n'
+        '1,a.png,0,10,10,50,50,0.9,-1,fish,0.9\n'  # inside: untouched
+        '2,a.png,0,-20,10,40,50,0.9,-1,fish,0.9\n'  # 2/3 visible: clipped
+        '3,a.png,0,-100,10,-40,50,0.9,-1,fish,0.9\n'  # fully outside: dropped
+        '4,a.png,0,630,300,730,400,0.9,-1,fish,0.9\n'  # 10% visible: dropped
+        '5,a.png,0,630.5,5,650,20,0.9,-1,fish,0.9\n',  # clipped, keeps decimals
+        encoding='utf-8',
+    )
+    out, clipped, dropped = clip_viame_csv_to_frame(str(source), 640, 480)
+    lines = Path(out).read_text(encoding='utf-8').splitlines()
+    assert lines[0] == '# metadata'
+    assert lines[1] == '1,a.png,0,10,10,50,50,0.9,-1,fish,0.9'
+    assert lines[2] == '2,a.png,0,0,10,40,50,0.9,-1,fish,0.9'
+    assert lines[3] == '5,a.png,0,630.500,5,640,20,0.9,-1,fish,0.9'
+    assert len(lines) == 4
+    assert (clipped, dropped) == (2, 2)
+
+
+def test_camera_frame_size(tmp_path: Path):
+    meta = {'ffprobe_info': {'width': '640', 'height': '512'}}
+    assert camera_frame_size(meta, ['/tmp/x.mp4'], constants.VideoType) == (640, 512)
+    assert camera_frame_size({}, ['/tmp/x.mp4'], constants.VideoType) is None
+    from PIL import Image
+
+    image_path = tmp_path / 'frame.png'
+    Image.new('L', (320, 240)).save(image_path)
+    assert camera_frame_size({}, [str(image_path)], constants.ImageSequenceType) == (320, 240)
+    assert camera_frame_size({}, [], constants.ImageSequenceType) is None
diff --git a/server/tests/test_viame_config_env.py b/server/tests/test_viame_config_env.py
new file mode 100644
index 000000000..d7c9c568b
--- /dev/null
+++ b/server/tests/test_viame_config_env.py
@@ -0,0 +1,25 @@
+from unittest import mock
+
+from dive_tasks.viame_config import get_gpu_environment
+
+
+def test_gpu_environment_drops_dive_venv():
+    """VIAME must not inherit DIVE's venv: kwiver segfaults with VIRTUAL_ENV set."""
+    worker_env = {
+        "PATH": "/opt/dive/local/venv/bin:/usr/local/bin:/usr/bin",
+        "VIRTUAL_ENV": "/opt/dive/local/venv",
+        "UV_PYTHON": "3.11",
+        "UV_PYTHON_INSTALL_DIR": "/opt/dive/local/uv-python",
+        "KEEP_ME": "1",
+    }
+    with (
+        mock.patch.dict("os.environ", worker_env, clear=True),
+        mock.patch("dive_tasks.viame_config.getGPUs", return_value=[]),
+    ):
+        env = get_gpu_environment()
+
+    assert "VIRTUAL_ENV" not in env
+    assert "UV_PYTHON" not in env
+    assert "UV_PYTHON_INSTALL_DIR" not in env
+    assert "/opt/dive/local/venv/bin" not in env["PATH"]
+    assert env["KEEP_ME"] == "1"