From 3c709c968ca0fd789680899bea2355f673f79595 Mon Sep 17 00:00:00 2001
From: Matt Dawkins <matt.dawkins@kitware.com>
Date: Fri, 7 Aug 2026 15:01:35 -0400
Subject: [PATCH 1/7] Regroup desktop import buttons

Tiled GeoTIFF / TIFF moves into the Image Sequence dropdown, and
Bulk Import gains a single/multi camera dropdown that takes over
the MultiCam Batch entry.
---
 .../dive-common/components/ImportButton.vue   | 72 ++++++++++++++++++-
 .../desktop/frontend/components/Recent.vue    | 13 +---
 2 files changed, 72 insertions(+), 13 deletions(-)

diff --git a/client/dive-common/components/ImportButton.vue b/client/dive-common/components/ImportButton.vue
index 8020ef548..f07e12ad6 100644
--- a/client/dive-common/components/ImportButton.vue
+++ b/client/dive-common/components/ImportButton.vue
@@ -31,6 +31,14 @@ export default defineComponent({
       type: Boolean,
       default: false,
     },
+    largeImageImport: { // Offer tiled GeoTIFF / TIFF alongside the other sources
+      type: Boolean,
+      default: false,
+    },
+    bulkImport: { // Single/multi camera choice for bulk folder scans
+      type: Boolean,
+      default: false,
+    },
     buttonAttrs: {
       type: Object,
       default: () => DefaultButtonAttrs,
@@ -45,9 +53,11 @@ export default defineComponent({
     },
   },
   setup(props) {
-    const menuWidth = computed(() => (props.batchMultiCamImport ? 240 : 180));
+    const menuWidth = computed(() => (props.batchMultiCamImport || props.largeImageImport ? 240 : 180));
+    const hasDropdown = computed(() => props.multiCamImport || props.bulkImport);
 
     return {
+      hasDropdown,
       menuWidth,
     };
   },
@@ -110,7 +120,7 @@ export default defineComponent({
             </v-icon>
           </div>
           <v-icon
-            v-if="multiCamImport"
+            v-if="hasDropdown"
             class="button-dropdown col-1"
             v-on="on"
           >
@@ -119,7 +129,37 @@ export default defineComponent({
         </v-btn>
       </template>
       <v-card outlined>
-        <v-list dense>
+        <v-list
+          v-if="bulkImport"
+          dense
+        >
+          <v-list-item
+            style="align-items':'center"
+            @click="$emit('open', openType)"
+          >
+            <v-list-item-icon>
+              <v-icon>mdi-folder-multiple</v-icon>
+            </v-list-item-icon>
+            <v-list-item-content>
+              <v-list-item-title>Single Camera</v-list-item-title>
+            </v-list-item-content>
+          </v-list-item>
+          <v-list-item
+            style="align-items':'center"
+            @click="$emit('multi-cam-batch')"
+          >
+            <v-list-item-icon>
+              <v-icon>mdi-folder-multiple-image</v-icon>
+            </v-list-item-icon>
+            <v-list-item-content>
+              <v-list-item-title>Multi-Camera</v-list-item-title>
+            </v-list-item-content>
+          </v-list-item>
+        </v-list>
+        <v-list
+          v-else
+          dense
+        >
           <v-list-item
             v-if="['image-sequence', 'large-image'].includes(openType)"
             style="align-items':'center"
@@ -156,6 +196,32 @@ export default defineComponent({
               <v-list-item-title>Image List</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
+          <v-tooltip
+            v-if="largeImageImport"
+            right
+            max-width="360"
+            open-delay="50"
+          >
+            <template #activator="{ on: tooltipOn }">
+              <v-list-item
+                style="align-items':'center"
+                v-on="tooltipOn"
+                @click="$emit('open', 'large-image')"
+              >
+                <v-list-item-icon>
+                  <v-icon>mdi-map</v-icon>
+                </v-list-item-icon>
+                <v-list-item-content>
+                  <v-list-item-title>Tiled GeoTIFF / TIFF</v-list-item-title>
+                </v-list-item-content>
+              </v-list-item>
+            </template>
+            <span>
+              Open a high-resolution geospatial image for tiled viewing. Supported formats:
+              .tif, .tiff, .geotiff. Files should include internal pyramid overviews
+              (COG recommended) for best performance.
+            </span>
+          </v-tooltip>
           <v-list-item
             style="align-items':'center"
             @click="$emit('multi-cam', { stereo: true, openType })"
diff --git a/client/platform/desktop/frontend/components/Recent.vue b/client/platform/desktop/frontend/components/Recent.vue
index 011ec6f3d..cd88cef4b 100644
--- a/client/platform/desktop/frontend/components/Recent.vue
+++ b/client/platform/desktop/frontend/components/Recent.vue
@@ -425,7 +425,9 @@ export default defineComponent({
               icon="mdi-folder-multiple"
               open-type="bulk"
               class="my-3"
+              :bulk-import="true"
               @open="open($event)"
+              @multi-cam-batch="importMultiCamBatchDialog = true"
             />
             <ImportButton
               name="Open Image Sequence"
@@ -433,10 +435,9 @@ export default defineComponent({
               open-type="image-sequence"
               class="my-3"
               :multi-cam-import="true"
-              :batch-multi-cam-import="true"
+              :large-image-import="true"
               @open="open($event)"
               @multi-cam="openMultiCamDialog"
-              @multi-cam-batch="importMultiCamBatchDialog = true"
             />
             <ImportButton
               name="Open Video"
@@ -447,14 +448,6 @@ export default defineComponent({
               @open="open($event)"
               @multi-cam="openMultiCamDialog"
             />
-            <ImportButton
-              name="Open Tiled GeoTIFF / TIFF"
-              icon="mdi-map"
-              open-type="large-image"
-              class="my-3"
-              tooltip="Open a high-resolution geospatial image for tiled viewing. Supported formats: .tif, .tiff, .geotiff. Files should include internal pyramid overviews (COG recommended) for best performance."
-              @open="open($event)"
-            />
           </v-col>
         </v-row>
         <v-row>

From 9a584b4ce2dec333470773f5ae2bb128ed5c211c Mon Sep 17 00:00:00 2001
From: Matt Dawkins <matt.dawkins@kitware.com>
Date: Fri, 7 Aug 2026 15:11:41 -0400
Subject: [PATCH 2/7] Normalize multi-camera and stereo wording

Multi-Camera, Single-Camera, and Stereo replace MultiCam, Single Camera,
and Stereoscopic in user-facing labels.
---
 client/dive-common/components/ImportButton.vue            | 8 ++++----
 .../dive-common/components/ImportMultiCamBatchDialog.vue  | 2 +-
 client/dive-common/components/MultiCamTools.vue           | 4 ++--
 client/dive-common/components/RunPipelineMenu.vue         | 2 +-
 client/dive-common/components/Viewer.vue                  | 4 ++--
 client/dive-common/multicamDisplay.spec.ts                | 4 ++--
 client/dive-common/multicamDisplay.ts                     | 2 +-
 client/dive-common/store/context.ts                       | 2 +-
 client/platform/desktop/frontend/api.ts                   | 2 +-
 client/platform/web-girder/views/Upload.vue               | 4 ++--
 .../components/Tracks/sidebar/SideBarTrackItemView.vue    | 2 +-
 11 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/client/dive-common/components/ImportButton.vue b/client/dive-common/components/ImportButton.vue
index f07e12ad6..581b5a4f8 100644
--- a/client/dive-common/components/ImportButton.vue
+++ b/client/dive-common/components/ImportButton.vue
@@ -141,7 +141,7 @@ export default defineComponent({
               <v-icon>mdi-folder-multiple</v-icon>
             </v-list-item-icon>
             <v-list-item-content>
-              <v-list-item-title>Single Camera</v-list-item-title>
+              <v-list-item-title>Single-Camera</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
           <v-list-item
@@ -230,7 +230,7 @@ export default defineComponent({
               <v-icon>mdi-binoculars</v-icon>
             </v-list-item-icon>
             <v-list-item-content>
-              <v-list-item-title>Stereoscopic</v-list-item-title>
+              <v-list-item-title>Stereo</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
           <v-list-item
@@ -241,7 +241,7 @@ export default defineComponent({
               <v-icon>mdi-camera-burst</v-icon>
             </v-list-item-icon>
             <v-list-item-content>
-              <v-list-item-title>MultiCam</v-list-item-title>
+              <v-list-item-title>Multi-Camera</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
           <v-list-item
@@ -253,7 +253,7 @@ export default defineComponent({
               <v-icon>mdi-folder-multiple-image</v-icon>
             </v-list-item-icon>
             <v-list-item-content>
-              <v-list-item-title>MultiCam Batch</v-list-item-title>
+              <v-list-item-title>Multi-Camera Batch</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
         </v-list>
diff --git a/client/dive-common/components/ImportMultiCamBatchDialog.vue b/client/dive-common/components/ImportMultiCamBatchDialog.vue
index 9873c3780..c2a9ef12d 100644
--- a/client/dive-common/components/ImportMultiCamBatchDialog.vue
+++ b/client/dive-common/components/ImportMultiCamBatchDialog.vue
@@ -233,7 +233,7 @@ export default defineComponent({
     class="import-card"
   >
     <v-card-title class="text-h5">
-      Batch Multicam Import
+      Batch Multi-Camera Import
     </v-card-title>
     <v-card-text>
       <p class="grey--text text--lighten-1">
diff --git a/client/dive-common/components/MultiCamTools.vue b/client/dive-common/components/MultiCamTools.vue
index 484a9e484..b11e9f231 100644
--- a/client/dive-common/components/MultiCamTools.vue
+++ b/client/dive-common/components/MultiCamTools.vue
@@ -18,7 +18,7 @@ interface CameraTrackData {
 }
 export default defineComponent({
   name: 'MultiCamTools',
-  description: 'MultiCam Tools',
+  description: 'Multi-Camera Tools',
   components: { TooltipBtn },
   setup() {
     const selectedCamera = useSelectedCamera();
@@ -127,7 +127,7 @@ export default defineComponent({
 <template>
   <div class="mx-4">
     <span class="text-body-2">
-      Multicam Tools for creating tracks, linking and unlinking tracks
+      Multi-Camera Tools for creating tracks, linking and unlinking tracks
     </span>
     <v-divider class="my-3" />
     <v-divider class="my-3" />
diff --git a/client/dive-common/components/RunPipelineMenu.vue b/client/dive-common/components/RunPipelineMenu.vue
index d25aabe51..9bdfbaab0 100644
--- a/client/dive-common/components/RunPipelineMenu.vue
+++ b/client/dive-common/components/RunPipelineMenu.vue
@@ -237,7 +237,7 @@ export default defineComponent({
       && stereoPipelineMarker !== pipeline.type)) {
         const cameraNames = props.selectedDatasetIds.map((item) => parentDatasetId(item));
         const result = await prompt({
-          title: `Running Single Camera Pipeline on ${cameraNames[0]}`,
+          title: `Running Single-Camera Pipeline on ${cameraNames[0]}`,
           text: ['Running a single pipeline on multi-camera data can produce conflicting track Ids',
             'Suggest Cancelling and deleting all existing tracks to ensure proper display of the output',
           ],
diff --git a/client/dive-common/components/Viewer.vue b/client/dive-common/components/Viewer.vue
index 9e18ebd9c..76fb4f7e9 100644
--- a/client/dive-common/components/Viewer.vue
+++ b/client/dive-common/components/Viewer.vue
@@ -1594,7 +1594,7 @@ export default defineComponent({
           });
           context.register({
             component: MultiCamToolsVue,
-            description: 'Multi Camera Tools',
+            description: 'Multi-Camera Tools',
           });
           // Camera registration applies to true multi-camera datasets only;
           // stereo pairs are aligned by their calibration file instead.
@@ -1612,7 +1612,7 @@ export default defineComponent({
         } else {
           context.unregister({
             component: MultiCamToolsVue,
-            description: 'Multi Camera Tools',
+            description: 'Multi-Camera Tools',
           });
           context.unregister({
             component: RegistrationToolsVue,
diff --git a/client/dive-common/multicamDisplay.spec.ts b/client/dive-common/multicamDisplay.spec.ts
index d7a5a1fc5..a006725aa 100644
--- a/client/dive-common/multicamDisplay.spec.ts
+++ b/client/dive-common/multicamDisplay.spec.ts
@@ -19,8 +19,8 @@ describe('multicamDisplay', () => {
   it('returns icons and tooltips', () => {
     expect(getMultiCamIcon('stereo')).toBe('mdi-binoculars');
     expect(getMultiCamIcon('multicam')).toBe('mdi-camera-burst');
-    expect(getMultiCamTooltip('stereo')).toBe('Stereoscopic dataset');
-    expect(getMultiCamTooltip('multicam')).toBe('Multicamera dataset');
+    expect(getMultiCamTooltip('stereo')).toBe('Stereo dataset');
+    expect(getMultiCamTooltip('multicam')).toBe('Multi-Camera dataset');
   });
 
   it('orders cameras using cameraOrder when present', () => {
diff --git a/client/dive-common/multicamDisplay.ts b/client/dive-common/multicamDisplay.ts
index 10771eb33..fdea23d8f 100644
--- a/client/dive-common/multicamDisplay.ts
+++ b/client/dive-common/multicamDisplay.ts
@@ -27,7 +27,7 @@ export function getMultiCamIcon(subType: MultiCamSubType): string {
 }
 
 export function getMultiCamTooltip(subType: MultiCamSubType): string {
-  return subType === 'stereo' ? 'Stereoscopic dataset' : 'Multicamera dataset';
+  return subType === 'stereo' ? 'Stereo dataset' : 'Multi-Camera dataset';
 }
 
 /** Camera names in display order (import / storage order). */
diff --git a/client/dive-common/store/context.ts b/client/dive-common/store/context.ts
index 3b5521cc4..c87e3f30b 100644
--- a/client/dive-common/store/context.ts
+++ b/client/dive-common/store/context.ts
@@ -44,7 +44,7 @@ const componentMap: Record<string, ComponentMapItem> = {
     component: GroupSidebar,
   },
   [MultiCamTools.name]: {
-    description: 'Multi Camera Tools',
+    description: 'Multi-Camera Tools',
     component: MultiCamTools,
   },
   [RegistrationTools.name]: {
diff --git a/client/platform/desktop/frontend/api.ts b/client/platform/desktop/frontend/api.ts
index 1b8c1b3a8..38c074cee 100644
--- a/client/platform/desktop/frontend/api.ts
+++ b/client/platform/desktop/frontend/api.ts
@@ -312,7 +312,7 @@ async function exportMulticamEverything(
 ): Promise<string> {
   const parentId = id.split('/')[0];
   const location = await window.diveDesktop.showSaveDialog({
-    title: 'Export Multicamera Dataset',
+    title: 'Export Multi-Camera Dataset',
     defaultPath: joinPath(
       await window.diveDesktop.getAppPath('home'),
       `${parentId}.zip`,
diff --git a/client/platform/web-girder/views/Upload.vue b/client/platform/web-girder/views/Upload.vue
index 76d3f0682..58b2be221 100644
--- a/client/platform/web-girder/views/Upload.vue
+++ b/client/platform/web-girder/views/Upload.vue
@@ -481,7 +481,7 @@ export default defineComponent({
         const { data: datasetFolder } = await createGirderFolder({
           folderId: props.location._id,
           name: datasetName,
-          description: 'Multicamera dataset',
+          description: 'Multi-Camera dataset',
         });
         datasetFolderId = datasetFolder._id;
         const cameras: Record<string, { folderId: string; type?: string }> = {};
@@ -587,7 +587,7 @@ export default defineComponent({
           }
           if (stereo.value && !isAllowedStereoCalibrationFilename(calFile.name)) {
             throw new Error(
-              `Stereoscopic calibration must be ${stereoCalibrationAllowedExtensionsLabel()}.`,
+              `Stereo calibration must be ${stereoCalibrationAllowedExtensionsLabel()}.`,
             );
           }
           calibrationFileId = await uploadCalibrationItem(datasetFolder._id, calFile);
diff --git a/client/src/components/Tracks/sidebar/SideBarTrackItemView.vue b/client/src/components/Tracks/sidebar/SideBarTrackItemView.vue
index 67b03b003..61bdac927 100644
--- a/client/src/components/Tracks/sidebar/SideBarTrackItemView.vue
+++ b/client/src/components/Tracks/sidebar/SideBarTrackItemView.vue
@@ -255,7 +255,7 @@ export default defineComponent({
         <span v-else>
           <tooltip-btn
             icon="mdi-camera"
-            tooltip-text="Open MultiCamera Tools"
+            tooltip-text="Open Multi-Camera Tools"
             @click="openMultiCamTools"
           />
         </span>

From cf196c4659bb65d3cf837fe838990d28008a9050 Mon Sep 17 00:00:00 2001
From: Matt Dawkins <matt.dawkins@kitware.com>
Date: Fri, 7 Aug 2026 15:14:45 -0400
Subject: [PATCH 3/7] Drop hyphens from multi camera labels

---
 client/dive-common/components/ImportButton.vue            | 8 ++++----
 .../dive-common/components/ImportMultiCamBatchDialog.vue  | 2 +-
 .../ImportMultiCamDialog/ImportMultiCamDialog.vue         | 2 +-
 client/dive-common/components/MultiCamTools.vue           | 4 ++--
 client/dive-common/components/RunPipelineMenu.vue         | 2 +-
 client/dive-common/components/TrackSettingsPanel.vue      | 2 +-
 client/dive-common/components/Viewer.vue                  | 4 ++--
 client/dive-common/multicamDisplay.spec.ts                | 2 +-
 client/dive-common/multicamDisplay.ts                     | 2 +-
 client/dive-common/store/context.ts                       | 2 +-
 client/platform/desktop/frontend/api.ts                   | 2 +-
 client/platform/web-girder/views/Upload.vue               | 2 +-
 .../components/Tracks/sidebar/SideBarTrackItemView.vue    | 2 +-
 13 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/client/dive-common/components/ImportButton.vue b/client/dive-common/components/ImportButton.vue
index 581b5a4f8..d67384c80 100644
--- a/client/dive-common/components/ImportButton.vue
+++ b/client/dive-common/components/ImportButton.vue
@@ -141,7 +141,7 @@ export default defineComponent({
               <v-icon>mdi-folder-multiple</v-icon>
             </v-list-item-icon>
             <v-list-item-content>
-              <v-list-item-title>Single-Camera</v-list-item-title>
+              <v-list-item-title>Single Camera</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
           <v-list-item
@@ -152,7 +152,7 @@ export default defineComponent({
               <v-icon>mdi-folder-multiple-image</v-icon>
             </v-list-item-icon>
             <v-list-item-content>
-              <v-list-item-title>Multi-Camera</v-list-item-title>
+              <v-list-item-title>Multi Camera</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
         </v-list>
@@ -241,7 +241,7 @@ export default defineComponent({
               <v-icon>mdi-camera-burst</v-icon>
             </v-list-item-icon>
             <v-list-item-content>
-              <v-list-item-title>Multi-Camera</v-list-item-title>
+              <v-list-item-title>Multi Camera</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
           <v-list-item
@@ -253,7 +253,7 @@ export default defineComponent({
               <v-icon>mdi-folder-multiple-image</v-icon>
             </v-list-item-icon>
             <v-list-item-content>
-              <v-list-item-title>Multi-Camera Batch</v-list-item-title>
+              <v-list-item-title>Multi Camera Batch</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
         </v-list>
diff --git a/client/dive-common/components/ImportMultiCamBatchDialog.vue b/client/dive-common/components/ImportMultiCamBatchDialog.vue
index c2a9ef12d..114f30573 100644
--- a/client/dive-common/components/ImportMultiCamBatchDialog.vue
+++ b/client/dive-common/components/ImportMultiCamBatchDialog.vue
@@ -233,7 +233,7 @@ export default defineComponent({
     class="import-card"
   >
     <v-card-title class="text-h5">
-      Batch Multi-Camera Import
+      Batch Multi Camera Import
     </v-card-title>
     <v-card-text>
       <p class="grey--text text--lighten-1">
diff --git a/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamDialog.vue b/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamDialog.vue
index b226eee3c..7cf8a7e57 100644
--- a/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamDialog.vue
+++ b/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamDialog.vue
@@ -83,7 +83,7 @@ export default defineComponent({
     class="import-card px-3"
   >
     <v-card-title class="text-h5">
-      Import {{ stereo ? 'Stereo' : 'Multi-Camera' }}
+      Import {{ stereo ? 'Stereo' : 'Multi Camera' }}
       {{ dataType === 'image-sequence' ? 'Image Sequence' : 'Videos' }}
     </v-card-title>
     <v-card-text>
diff --git a/client/dive-common/components/MultiCamTools.vue b/client/dive-common/components/MultiCamTools.vue
index b11e9f231..62af20d9c 100644
--- a/client/dive-common/components/MultiCamTools.vue
+++ b/client/dive-common/components/MultiCamTools.vue
@@ -18,7 +18,7 @@ interface CameraTrackData {
 }
 export default defineComponent({
   name: 'MultiCamTools',
-  description: 'Multi-Camera Tools',
+  description: 'Multi Camera Tools',
   components: { TooltipBtn },
   setup() {
     const selectedCamera = useSelectedCamera();
@@ -127,7 +127,7 @@ export default defineComponent({
 <template>
   <div class="mx-4">
     <span class="text-body-2">
-      Multi-Camera Tools for creating tracks, linking and unlinking tracks
+      Multi Camera Tools for creating tracks, linking and unlinking tracks
     </span>
     <v-divider class="my-3" />
     <v-divider class="my-3" />
diff --git a/client/dive-common/components/RunPipelineMenu.vue b/client/dive-common/components/RunPipelineMenu.vue
index 9bdfbaab0..d25aabe51 100644
--- a/client/dive-common/components/RunPipelineMenu.vue
+++ b/client/dive-common/components/RunPipelineMenu.vue
@@ -237,7 +237,7 @@ export default defineComponent({
       && stereoPipelineMarker !== pipeline.type)) {
         const cameraNames = props.selectedDatasetIds.map((item) => parentDatasetId(item));
         const result = await prompt({
-          title: `Running Single-Camera Pipeline on ${cameraNames[0]}`,
+          title: `Running Single Camera Pipeline on ${cameraNames[0]}`,
           text: ['Running a single pipeline on multi-camera data can produce conflicting track Ids',
             'Suggest Cancelling and deleting all existing tracks to ensure proper display of the output',
           ],
diff --git a/client/dive-common/components/TrackSettingsPanel.vue b/client/dive-common/components/TrackSettingsPanel.vue
index fa00103ee..e0aeb6a68 100644
--- a/client/dive-common/components/TrackSettingsPanel.vue
+++ b/client/dive-common/components/TrackSettingsPanel.vue
@@ -333,7 +333,7 @@ export default defineComponent({
       </v-row>
       <v-divider class="my-2" />
       <div class="subheading">
-        Multi-Camera Settings
+        Multi Camera Settings
       </div>
       <v-row
         align="end"
diff --git a/client/dive-common/components/Viewer.vue b/client/dive-common/components/Viewer.vue
index 76fb4f7e9..9e18ebd9c 100644
--- a/client/dive-common/components/Viewer.vue
+++ b/client/dive-common/components/Viewer.vue
@@ -1594,7 +1594,7 @@ export default defineComponent({
           });
           context.register({
             component: MultiCamToolsVue,
-            description: 'Multi-Camera Tools',
+            description: 'Multi Camera Tools',
           });
           // Camera registration applies to true multi-camera datasets only;
           // stereo pairs are aligned by their calibration file instead.
@@ -1612,7 +1612,7 @@ export default defineComponent({
         } else {
           context.unregister({
             component: MultiCamToolsVue,
-            description: 'Multi-Camera Tools',
+            description: 'Multi Camera Tools',
           });
           context.unregister({
             component: RegistrationToolsVue,
diff --git a/client/dive-common/multicamDisplay.spec.ts b/client/dive-common/multicamDisplay.spec.ts
index a006725aa..eb616abfc 100644
--- a/client/dive-common/multicamDisplay.spec.ts
+++ b/client/dive-common/multicamDisplay.spec.ts
@@ -20,7 +20,7 @@ describe('multicamDisplay', () => {
     expect(getMultiCamIcon('stereo')).toBe('mdi-binoculars');
     expect(getMultiCamIcon('multicam')).toBe('mdi-camera-burst');
     expect(getMultiCamTooltip('stereo')).toBe('Stereo dataset');
-    expect(getMultiCamTooltip('multicam')).toBe('Multi-Camera dataset');
+    expect(getMultiCamTooltip('multicam')).toBe('Multi Camera dataset');
   });
 
   it('orders cameras using cameraOrder when present', () => {
diff --git a/client/dive-common/multicamDisplay.ts b/client/dive-common/multicamDisplay.ts
index fdea23d8f..ca7b03189 100644
--- a/client/dive-common/multicamDisplay.ts
+++ b/client/dive-common/multicamDisplay.ts
@@ -27,7 +27,7 @@ export function getMultiCamIcon(subType: MultiCamSubType): string {
 }
 
 export function getMultiCamTooltip(subType: MultiCamSubType): string {
-  return subType === 'stereo' ? 'Stereo dataset' : 'Multi-Camera dataset';
+  return subType === 'stereo' ? 'Stereo dataset' : 'Multi Camera dataset';
 }
 
 /** Camera names in display order (import / storage order). */
diff --git a/client/dive-common/store/context.ts b/client/dive-common/store/context.ts
index c87e3f30b..3b5521cc4 100644
--- a/client/dive-common/store/context.ts
+++ b/client/dive-common/store/context.ts
@@ -44,7 +44,7 @@ const componentMap: Record<string, ComponentMapItem> = {
     component: GroupSidebar,
   },
   [MultiCamTools.name]: {
-    description: 'Multi-Camera Tools',
+    description: 'Multi Camera Tools',
     component: MultiCamTools,
   },
   [RegistrationTools.name]: {
diff --git a/client/platform/desktop/frontend/api.ts b/client/platform/desktop/frontend/api.ts
index 38c074cee..a166c1be2 100644
--- a/client/platform/desktop/frontend/api.ts
+++ b/client/platform/desktop/frontend/api.ts
@@ -312,7 +312,7 @@ async function exportMulticamEverything(
 ): Promise<string> {
   const parentId = id.split('/')[0];
   const location = await window.diveDesktop.showSaveDialog({
-    title: 'Export Multi-Camera Dataset',
+    title: 'Export Multi Camera Dataset',
     defaultPath: joinPath(
       await window.diveDesktop.getAppPath('home'),
       `${parentId}.zip`,
diff --git a/client/platform/web-girder/views/Upload.vue b/client/platform/web-girder/views/Upload.vue
index 58b2be221..4110827ce 100644
--- a/client/platform/web-girder/views/Upload.vue
+++ b/client/platform/web-girder/views/Upload.vue
@@ -481,7 +481,7 @@ export default defineComponent({
         const { data: datasetFolder } = await createGirderFolder({
           folderId: props.location._id,
           name: datasetName,
-          description: 'Multi-Camera dataset',
+          description: 'Multi Camera dataset',
         });
         datasetFolderId = datasetFolder._id;
         const cameras: Record<string, { folderId: string; type?: string }> = {};
diff --git a/client/src/components/Tracks/sidebar/SideBarTrackItemView.vue b/client/src/components/Tracks/sidebar/SideBarTrackItemView.vue
index 61bdac927..ff5e946d3 100644
--- a/client/src/components/Tracks/sidebar/SideBarTrackItemView.vue
+++ b/client/src/components/Tracks/sidebar/SideBarTrackItemView.vue
@@ -255,7 +255,7 @@ export default defineComponent({
         <span v-else>
           <tooltip-btn
             icon="mdi-camera"
-            tooltip-text="Open Multi-Camera Tools"
+            tooltip-text="Open Multi Camera Tools"
             @click="openMultiCamTools"
           />
         </span>

From ed004a901d31d9b5dca24adbdb7989505c984802 Mon Sep 17 00:00:00 2001
From: Matt Dawkins <matt.dawkins@kitware.com>
Date: Fri, 7 Aug 2026 15:25:35 -0400
Subject: [PATCH 4/7] Add bulk stereo import

Requires a left and right camera per dataset, resolved from l/left and
r/right name markers, exactly two cameras per collect, or sibling root
folders/videos that pair by marker. Attaches calibration when found.
---
 .../dive-common/components/ImportButton.vue   |  16 +
 .../components/ImportMultiCamBatchDialog.vue  |  23 +-
 client/dive-common/stereoBatchScan.spec.ts    | 188 ++++++++++
 client/dive-common/stereoBatchScan.ts         | 340 ++++++++++++++++++
 client/dive-common/stereoPairing.spec.ts      |  94 +++++
 client/dive-common/stereoPairing.ts           | 175 +++++++++
 client/platform/desktop/backend/ipcService.ts |   6 +
 .../platform/desktop/backend/native/common.ts |   1 +
 .../native/stereoCollectImport.spec.ts        | 190 ++++++++++
 .../backend/native/stereoCollectImport.ts     |  82 +++++
 client/platform/desktop/frontend/api.ts       |   5 +
 .../components/ImportStereoBatchDialog.vue    |  65 ++++
 .../desktop/frontend/components/Recent.vue    |  18 +
 13 files changed, 1196 insertions(+), 7 deletions(-)
 create mode 100644 client/dive-common/stereoBatchScan.spec.ts
 create mode 100644 client/dive-common/stereoBatchScan.ts
 create mode 100644 client/dive-common/stereoPairing.spec.ts
 create mode 100644 client/dive-common/stereoPairing.ts
 create mode 100644 client/platform/desktop/backend/native/stereoCollectImport.spec.ts
 create mode 100644 client/platform/desktop/backend/native/stereoCollectImport.ts
 create mode 100644 client/platform/desktop/frontend/components/ImportStereoBatchDialog.vue

diff --git a/client/dive-common/components/ImportButton.vue b/client/dive-common/components/ImportButton.vue
index d67384c80..3c21b4972 100644
--- a/client/dive-common/components/ImportButton.vue
+++ b/client/dive-common/components/ImportButton.vue
@@ -39,6 +39,10 @@ export default defineComponent({
       type: Boolean,
       default: false,
     },
+    stereoBatchImport: { // Batch import of stereo (left/right) datasets
+      type: Boolean,
+      default: false,
+    },
     buttonAttrs: {
       type: Object,
       default: () => DefaultButtonAttrs,
@@ -155,6 +159,18 @@ export default defineComponent({
               <v-list-item-title>Multi Camera</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
+          <v-list-item
+            v-if="stereoBatchImport"
+            style="align-items':'center"
+            @click="$emit('stereo-batch')"
+          >
+            <v-list-item-icon>
+              <v-icon>mdi-binoculars</v-icon>
+            </v-list-item-icon>
+            <v-list-item-content>
+              <v-list-item-title>Stereo</v-list-item-title>
+            </v-list-item-content>
+          </v-list-item>
         </v-list>
         <v-list
           v-else
diff --git a/client/dive-common/components/ImportMultiCamBatchDialog.vue b/client/dive-common/components/ImportMultiCamBatchDialog.vue
index 114f30573..5323f06f0 100644
--- a/client/dive-common/components/ImportMultiCamBatchDialog.vue
+++ b/client/dive-common/components/ImportMultiCamBatchDialog.vue
@@ -55,6 +55,20 @@ export default defineComponent({
       type: String,
       default: 'Choose Root Folder',
     },
+    title: {
+      type: String,
+      default: 'Batch Multi Camera Import',
+    },
+    description: {
+      type: String,
+      default: (
+        'Select a top-level folder whose subfolders are collects, each holding the same '
+        + 'camera subfolders (for example EO, IR, UV). One multi camera dataset is created '
+        + 'per collect. Registration .json files next to the camera folders are attached '
+        + 'automatically. Flat collects of *_rgb / *_ir / *_uv images become one dataset '
+        + 'with a camera per modality.'
+      ),
+    },
   },
 
   setup(props) {
@@ -233,16 +247,11 @@ export default defineComponent({
     class="import-card"
   >
     <v-card-title class="text-h5">
-      Batch Multi Camera Import
+      {{ title }}
     </v-card-title>
     <v-card-text>
       <p class="grey--text text--lighten-1">
-        Select a top-level folder whose subfolders are collects, each holding
-        the same camera subfolders (for example EO, IR, UV). One multicam
-        dataset is created per collect. Registration .json files next to the
-        camera folders are attached automatically. Flat collects of
-        *_rgb / *_ir / *_uv images become one dataset with a camera per
-        modality.
+        {{ description }}
       </p>
       <v-row
         no-gutters
diff --git a/client/dive-common/stereoBatchScan.spec.ts b/client/dive-common/stereoBatchScan.spec.ts
new file mode 100644
index 000000000..31dd9185d
--- /dev/null
+++ b/client/dive-common/stereoBatchScan.spec.ts
@@ -0,0 +1,188 @@
+import { CollectSubfolderScan } from './multiCamBatchScan';
+import {
+  StereoBatchRawScan,
+  StereoCollectRawScan,
+  scanStereoBatchFromScan,
+} from './stereoBatchScan';
+
+function subfolders(
+  root: string,
+  entries: [string, number][],
+): Map<string, CollectSubfolderScan> {
+  const map = new Map<string, CollectSubfolderScan>();
+  entries.forEach(([folderName, imageCount]) => {
+    map.set(folderName.toLowerCase(), {
+      folderName,
+      path: `${root}/${folderName}`,
+      entryCount: imageCount,
+      imageCount,
+    });
+  });
+  return map;
+}
+
+function collect(
+  name: string,
+  entries: [string, number][],
+  extra: Partial<StereoCollectRawScan> = {},
+): StereoCollectRawScan {
+  const path = `/survey/${name}`;
+  return {
+    name,
+    path,
+    subfolders: subfolders(path, entries),
+    ...extra,
+  };
+}
+
+function scan(raw: Partial<StereoBatchRawScan>) {
+  return scanStereoBatchFromScan({ rootPath: '/survey', collects: [], ...raw });
+}
+
+describe('scanStereoBatchFromScan', () => {
+  it('resolves left/right camera folders per collect', () => {
+    const result = scan({
+      collects: [
+        collect('collect1', [['left', 10], ['right', 10]]),
+        collect('collect2', [['left', 8], ['right', 8]]),
+      ],
+    });
+    expect(result.problems).toEqual([]);
+    expect(result.cameraNames).toEqual(['left', 'right']);
+    expect(result.collects).toHaveLength(2);
+    const [first] = result.collects;
+    expect(first.importArgs?.sourceList.left.sourcePath).toBe('/survey/collect1/left');
+    expect(first.importArgs?.sourceList.right.sourcePath).toBe('/survey/collect1/right');
+    expect(first.importArgs?.defaultDisplay).toBe('left');
+    expect(first.importArgs?.type).toBe('image-sequence');
+  });
+
+  it('resolves marker suffixed camera folders', () => {
+    const result = scan({
+      collects: [collect('collect1', [['cam_L', 5], ['cam_R', 5]])],
+    });
+    expect(result.collects[0].importArgs?.sourceList.left.sourcePath)
+      .toBe('/survey/collect1/cam_L');
+    expect(result.collects[0].importArgs?.sourceList.right.sourcePath)
+      .toBe('/survey/collect1/cam_R');
+  });
+
+  it('falls back to listing order for exactly two unnamed camera folders', () => {
+    const result = scan({
+      collects: [collect('collect1', [['camA', 5], ['camB', 5]])],
+    });
+    const [first] = result.collects;
+    expect(first.importArgs?.sourceList.left.sourcePath).toBe('/survey/collect1/camA');
+    expect(first.importArgs?.sourceList.right.sourcePath).toBe('/survey/collect1/camB');
+    expect(first.warnings.join(' ')).toContain('do not identify sides');
+  });
+
+  it('blocks a collect with three unnamed camera folders', () => {
+    const result = scan({
+      collects: [collect('collect1', [['eo', 5], ['ir', 5], ['uv', 5]])],
+    });
+    expect(result.collects[0].importArgs).toBeNull();
+    expect(result.collects[0].problems.join(' ')).toContain('No left and right camera folders');
+    expect(result.problems.join(' ')).toContain('No stereo datasets found');
+  });
+
+  it('pairs videos inside a collect folder', () => {
+    const result = scan({
+      collects: [collect('collect1', [], {
+        videoFiles: [
+          { name: 'a_left.mp4', path: '/survey/collect1/a_left.mp4' },
+          { name: 'a_right.mp4', path: '/survey/collect1/a_right.mp4' },
+        ],
+      })],
+    });
+    const [first] = result.collects;
+    expect(first.importArgs?.type).toBe('video');
+    expect(first.importArgs?.sourceList.left.sourcePath).toBe('/survey/collect1/a_left.mp4');
+  });
+
+  it('pairs sibling videos in the root into one dataset each', () => {
+    const result = scan({
+      rootVideoFiles: [
+        { name: 'dive01_left.mp4', path: '/survey/dive01_left.mp4' },
+        { name: 'dive01_right.mp4', path: '/survey/dive01_right.mp4' },
+        { name: 'dive02_L.mp4', path: '/survey/dive02_L.mp4' },
+        { name: 'dive02_R.mp4', path: '/survey/dive02_R.mp4' },
+      ],
+    });
+    expect(result.problems).toEqual([]);
+    expect(result.collects.map((c) => c.name)).toEqual(['dive01', 'dive02']);
+    expect(result.collects[1].importArgs?.sourceList.right.sourcePath)
+      .toBe('/survey/dive02_R.mp4');
+  });
+
+  it('pairs sibling image folders in the root', () => {
+    const result = scan({
+      collects: [
+        collect('run_L', [], { imageCount: 12 }),
+        collect('run_R', [], { imageCount: 12 }),
+      ],
+    });
+    expect(result.collects).toHaveLength(1);
+    expect(result.collects[0].name).toBe('run');
+    expect(result.collects[0].importArgs?.sourceList.left.sourcePath).toBe('/survey/run_L');
+  });
+
+  it('descends into L/R named folders that hold no images of their own', () => {
+    const result = scan({
+      collects: [
+        collect('run_L', [['left', 4], ['right', 4]]),
+        collect('run_R', [['left', 4], ['right', 4]]),
+      ],
+    });
+    expect(result.collects.map((c) => c.name)).toEqual(['run_L', 'run_R']);
+    expect(result.collects[0].importArgs?.sourceList.left.sourcePath)
+      .toBe('/survey/run_L/left');
+  });
+
+  it('attaches a collect calibration file and falls back to the root one', () => {
+    const result = scan({
+      collects: [
+        collect('collect1', [['left', 4], ['right', 4]], {
+          calibrationFile: '/survey/collect1/calibration.npz',
+        }),
+        collect('collect2', [['left', 4], ['right', 4]]),
+      ],
+      rootCalibrationFile: '/survey/shared_calibration.npz',
+    });
+    expect(result.collects[0].importArgs?.calibrationFile)
+      .toBe('/survey/collect1/calibration.npz');
+    expect(result.collects[1].importArgs?.calibrationFile)
+      .toBe('/survey/shared_calibration.npz');
+  });
+
+  it('warns when no calibration file is found', () => {
+    const result = scan({
+      collects: [collect('collect1', [['left', 4], ['right', 4]])],
+    });
+    expect(result.collects[0].warnings.join(' ')).toContain('No stereo calibration file');
+  });
+
+  it('warns when frame counts differ', () => {
+    const result = scan({
+      collects: [collect('collect1', [['left', 10], ['right', 8]])],
+    });
+    expect(result.collects[0].warnings.join(' ')).toContain('Frame counts differ');
+  });
+
+  it('reports an empty root', () => {
+    const result = scan({});
+    expect(result.problems.join(' ')).toContain('No folders or videos found');
+  });
+
+  it('keeps importable collects alongside blocked ones', () => {
+    const result = scan({
+      collects: [
+        collect('good', [['left', 4], ['right', 4]]),
+        collect('bad', [['eo', 4], ['ir', 4], ['uv', 4]]),
+      ],
+    });
+    expect(result.problems).toEqual([]);
+    expect(result.collects.find((c) => c.name === 'good')?.importArgs).not.toBeNull();
+    expect(result.collects.find((c) => c.name === 'bad')?.importArgs).toBeNull();
+  });
+});
diff --git a/client/dive-common/stereoBatchScan.ts b/client/dive-common/stereoBatchScan.ts
new file mode 100644
index 000000000..a1cd7a9e0
--- /dev/null
+++ b/client/dive-common/stereoBatchScan.ts
@@ -0,0 +1,340 @@
+/**
+ * Batch stereo import scan logic shared by desktop and web.
+ *
+ * Unlike the multi camera batch scan this one requires every dataset to resolve
+ * to a left and a right camera; anything that does not is reported and skipped.
+ * Three layouts are recognized:
+ *
+ *  1. A collect folder holding camera subfolders (or videos) whose names carry
+ *     l / left / r / right markers, including the plain `left` + `right` case.
+ *  2. A collect folder holding exactly two camera subfolders (or two videos)
+ *     with names that say nothing about sides; listing order decides.
+ *  3. Sibling folders or videos in the root whose names differ only by an L/R
+ *     marker (`dive01_left.mp4` + `dive01_right.mp4`); each pair is a dataset.
+ */
+import { MultiCamImportFolderArgs } from 'dive-common/apispec';
+import {
+  CollectSubfolderScan,
+  MultiCamBatchCamera,
+  MultiCamBatchCollect,
+  MultiCamBatchScanResult,
+} from 'dive-common/multiCamBatchScan';
+import { pairStereoNames } from 'dive-common/stereoPairing';
+
+/** Camera names a stereo dataset must use for the importer to mark it stereo. */
+export const StereoCameraNames = ['left', 'right'] as const;
+
+/** A video file discovered during a stereo batch scan. */
+export interface StereoVideoScan {
+  name: string;
+  path: string;
+}
+
+/** One immediate child folder of the scan root. */
+export interface StereoCollectRawScan {
+  name: string;
+  path: string;
+  /** Immediate camera subfolders, keyed by lower-cased folder name. */
+  subfolders: Map<string, CollectSubfolderScan>;
+  /** Video files sitting directly in this folder. */
+  videoFiles?: StereoVideoScan[];
+  /** Images sitting directly in this folder (makes it a camera, not a collect). */
+  imageCount?: number;
+  /** Stereo calibration file found in this folder. */
+  calibrationFile?: string | null;
+}
+
+export interface StereoBatchRawScan {
+  rootPath: string;
+  collects: StereoCollectRawScan[];
+  /** Video files sitting directly in the root, for root level L/R pairing. */
+  rootVideoFiles?: StereoVideoScan[];
+  /** Calibration file in the root, used when a collect has none of its own. */
+  rootCalibrationFile?: string | null;
+}
+
+interface StereoCameraSource {
+  sourcePath: string;
+  /** Frame count for image cameras; videos report no count. */
+  imageCount?: number;
+}
+
+function lastPathSegment(path: string): string {
+  return path.replace(/\\/g, '/').split('/').filter(Boolean).pop() ?? '';
+}
+
+function buildStereoCollect(options: {
+  name: string;
+  path: string;
+  datasetName: string;
+  left: StereoCameraSource;
+  right: StereoCameraSource;
+  type: 'image-sequence' | 'video';
+  calibrationFile?: string | null;
+  warnings: string[];
+}): MultiCamBatchCollect {
+  const {
+    name, path, datasetName, left, right, type, calibrationFile, warnings,
+  } = options;
+
+  const cameras: MultiCamBatchCamera[] = [
+    { name: 'left', sourcePath: left.sourcePath, imageCount: left.imageCount ?? 0 },
+    { name: 'right', sourcePath: right.sourcePath, imageCount: right.imageCount ?? 0 },
+  ];
+
+  const allWarnings = [...warnings];
+  if (type === 'image-sequence'
+    && left.imageCount !== undefined && right.imageCount !== undefined
+    && left.imageCount !== right.imageCount) {
+    allWarnings.push(
+      `Frame counts differ across cameras (left: ${left.imageCount}, right: ${right.imageCount})`,
+    );
+  }
+  if (!calibrationFile) {
+    allWarnings.push(
+      'No stereo calibration file found; import it later to enable measurement',
+    );
+  }
+
+  const sourceList: MultiCamImportFolderArgs['sourceList'] = {
+    left: { sourcePath: left.sourcePath, trackFile: '' },
+    right: { sourcePath: right.sourcePath, trackFile: '' },
+  };
+
+  return {
+    name,
+    path,
+    cameras,
+    transformFiles: [],
+    problems: [],
+    warnings: allWarnings,
+    importArgs: {
+      datasetName,
+      defaultDisplay: 'left',
+      cameraOrder: ['left', 'right'],
+      sourceList,
+      type,
+      ...(calibrationFile ? { calibrationFile } : {}),
+    },
+  };
+}
+
+function blockedCollect(
+  name: string,
+  path: string,
+  problems: string[],
+): MultiCamBatchCollect {
+  return {
+    name,
+    path,
+    cameras: [],
+    transformFiles: [],
+    problems,
+    warnings: [],
+    importArgs: null,
+  };
+}
+
+/** Resolve one collect folder to a left/right pair using layouts 1 and 2. */
+function resolveCollect(
+  collect: StereoCollectRawScan,
+  rootCalibrationFile: string | null,
+): MultiCamBatchCollect {
+  const calibrationFile = collect.calibrationFile ?? rootCalibrationFile;
+  const imageSubfolders = [...collect.subfolders.values()]
+    .filter((subfolder) => subfolder.imageCount > 0)
+    .sort((a, b) => a.folderName.localeCompare(b.folderName));
+  const videoFiles = [...(collect.videoFiles ?? [])]
+    .sort((a, b) => a.name.localeCompare(b.name));
+
+  const toCamera = (subfolder: CollectSubfolderScan): StereoCameraSource => ({
+    sourcePath: subfolder.path,
+    imageCount: subfolder.imageCount,
+  });
+  const toVideoCamera = (video: StereoVideoScan): StereoCameraSource => ({
+    sourcePath: video.path,
+  });
+
+  if (imageSubfolders.length) {
+    const { pairs } = pairStereoNames(imageSubfolders, (subfolder) => subfolder.folderName);
+    if (pairs.length === 1) {
+      return buildStereoCollect({
+        name: collect.name,
+        path: collect.path,
+        datasetName: collect.name,
+        left: toCamera(pairs[0].left),
+        right: toCamera(pairs[0].right),
+        type: 'image-sequence',
+        calibrationFile,
+        warnings: [],
+      });
+    }
+    if (pairs.length > 1) {
+      return blockedCollect(collect.name, collect.path, [
+        `Found ${pairs.length} left/right camera folder pairs; expected one stereo pair`,
+      ]);
+    }
+    if (imageSubfolders.length === 2) {
+      return buildStereoCollect({
+        name: collect.name,
+        path: collect.path,
+        datasetName: collect.name,
+        left: toCamera(imageSubfolders[0]),
+        right: toCamera(imageSubfolders[1]),
+        type: 'image-sequence',
+        calibrationFile,
+        warnings: [
+          `Camera folder names do not identify sides; "${imageSubfolders[0].folderName}" `
+          + `was taken as left and "${imageSubfolders[1].folderName}" as right`,
+        ],
+      });
+    }
+    return blockedCollect(collect.name, collect.path, [
+      'No left and right camera folders found (looked for l/left and r/right names, '
+      + `or exactly two camera folders; found ${imageSubfolders.length}: `
+      + `${imageSubfolders.map((subfolder) => subfolder.folderName).join(', ')})`,
+    ]);
+  }
+
+  if (videoFiles.length) {
+    const { pairs } = pairStereoNames(videoFiles, (video) => video.name);
+    if (pairs.length === 1) {
+      return buildStereoCollect({
+        name: collect.name,
+        path: collect.path,
+        datasetName: collect.name,
+        left: toVideoCamera(pairs[0].left),
+        right: toVideoCamera(pairs[0].right),
+        type: 'video',
+        calibrationFile,
+        warnings: [],
+      });
+    }
+    if (pairs.length > 1) {
+      return blockedCollect(collect.name, collect.path, [
+        `Found ${pairs.length} left/right video pairs; expected one stereo pair`,
+      ]);
+    }
+    if (videoFiles.length === 2) {
+      return buildStereoCollect({
+        name: collect.name,
+        path: collect.path,
+        datasetName: collect.name,
+        left: toVideoCamera(videoFiles[0]),
+        right: toVideoCamera(videoFiles[1]),
+        type: 'video',
+        calibrationFile,
+        warnings: [
+          `Video names do not identify sides; "${videoFiles[0].name}" was taken as left `
+          + `and "${videoFiles[1].name}" as right`,
+        ],
+      });
+    }
+    return blockedCollect(collect.name, collect.path, [
+      'No left and right videos found (looked for l/left and r/right names, or exactly '
+      + `two videos; found ${videoFiles.length}: ${videoFiles.map((v) => v.name).join(', ')})`,
+    ]);
+  }
+
+  return blockedCollect(collect.name, collect.path, [
+    'No camera folders with images and no videos found',
+  ]);
+}
+
+function uniqueName(name: string, taken: Set<string>): string {
+  if (!taken.has(name)) {
+    taken.add(name);
+    return name;
+  }
+  let suffix = 2;
+  while (taken.has(`${name}_${suffix}`)) {
+    suffix += 1;
+  }
+  const unique = `${name}_${suffix}`;
+  taken.add(unique);
+  return unique;
+}
+
+/**
+ * Build a stereo batch scan result from a pre-scanned root folder.
+ */
+export function scanStereoBatchFromScan(raw: StereoBatchRawScan): MultiCamBatchScanResult {
+  const { rootPath } = raw;
+  const rootCalibrationFile = raw.rootCalibrationFile ?? null;
+  const rootLabel = lastPathSegment(rootPath);
+  const problems: string[] = [];
+  const collects: MultiCamBatchCollect[] = [];
+  const takenNames = new Set<string>();
+
+  // Layout 3, videos: root level video files whose names pair by L/R marker.
+  const rootVideos = [...(raw.rootVideoFiles ?? [])].sort((a, b) => a.name.localeCompare(b.name));
+  const videoPairing = pairStereoNames(rootVideos, (video) => video.name);
+  videoPairing.pairs.forEach((pair) => {
+    const stem = pair.stem || rootLabel;
+    const name = uniqueName(stem, takenNames);
+    collects.push(buildStereoCollect({
+      name,
+      path: rootPath,
+      datasetName: name,
+      left: { sourcePath: pair.left.path },
+      right: { sourcePath: pair.right.path },
+      type: 'video',
+      calibrationFile: rootCalibrationFile,
+      warnings: [],
+    }));
+  });
+
+  // Layout 3, folders: root level folders that hold images directly and whose
+  // names pair by L/R marker. Folders without their own images are collects to
+  // descend into instead, even when their names happen to pair.
+  const cameraFolders = raw.collects.filter((collect) => (collect.imageCount ?? 0) > 0);
+  const folderPairing = pairStereoNames(cameraFolders, (collect) => collect.name);
+  const pairedFolders = new Set<StereoCollectRawScan>();
+  folderPairing.pairs.forEach((pair) => {
+    pairedFolders.add(pair.left);
+    pairedFolders.add(pair.right);
+    const stem = pair.stem || rootLabel;
+    const name = uniqueName(stem, takenNames);
+    collects.push(buildStereoCollect({
+      name,
+      path: rootPath,
+      datasetName: name,
+      left: {
+        sourcePath: pair.left.path,
+        imageCount: pair.left.imageCount,
+      },
+      right: {
+        sourcePath: pair.right.path,
+        imageCount: pair.right.imageCount,
+      },
+      type: 'image-sequence',
+      calibrationFile: pair.left.calibrationFile ?? rootCalibrationFile,
+      warnings: [],
+    }));
+  });
+
+  // Layouts 1 and 2: everything else is a collect folder holding both cameras.
+  raw.collects
+    .filter((collect) => !pairedFolders.has(collect))
+    .forEach((collect) => {
+      const resolved = resolveCollect(collect, rootCalibrationFile);
+      collects.push({ ...resolved, name: uniqueName(resolved.name, takenNames) });
+    });
+
+  if (!raw.collects.length && !rootVideos.length) {
+    problems.push(`No folders or videos found in ${rootPath}`);
+  } else if (!collects.some((collect) => collect.importArgs)) {
+    problems.push(
+      'No stereo datasets found. Each dataset needs a left and a right camera: name '
+      + 'folders or videos with l/left and r/right markers, or leave exactly two '
+      + 'camera folders or videos per collect folder.',
+    );
+  }
+
+  return {
+    rootPath,
+    cameraNames: [...StereoCameraNames],
+    collects,
+    problems,
+  };
+}
diff --git a/client/dive-common/stereoPairing.spec.ts b/client/dive-common/stereoPairing.spec.ts
new file mode 100644
index 000000000..a9a206692
--- /dev/null
+++ b/client/dive-common/stereoPairing.spec.ts
@@ -0,0 +1,94 @@
+import {
+  detectStereoSideByCharDiff,
+  detectStereoSideToken,
+  pairStereoNames,
+} from './stereoPairing';
+
+const names = (list: string[]) => pairStereoNames(list, (name) => name);
+
+describe('detectStereoSideToken', () => {
+  it('matches bare left and right', () => {
+    expect(detectStereoSideToken('left')).toEqual({ stem: '', side: 'left' });
+    expect(detectStereoSideToken('RIGHT')).toEqual({ stem: '', side: 'right' });
+  });
+
+  it('matches delimited markers of any case', () => {
+    expect(detectStereoSideToken('dive01_L.mp4')).toEqual({ stem: 'dive01', side: 'left' });
+    expect(detectStereoSideToken('dive01-Right.mp4')).toEqual({ stem: 'dive01', side: 'right' });
+    expect(detectStereoSideToken('cam l 02')).toEqual({ stem: 'cam_02', side: 'left' });
+  });
+
+  it('does not match substrings inside other tokens', () => {
+    expect(detectStereoSideToken('cam_ir')).toBeNull();
+    expect(detectStereoSideToken('rgb')).toBeNull();
+    expect(detectStereoSideToken('lateral')).toBeNull();
+  });
+
+  it('rejects names carrying both markers', () => {
+    expect(detectStereoSideToken('left_right')).toBeNull();
+  });
+});
+
+describe('detectStereoSideByCharDiff', () => {
+  it('matches a glued single character marker', () => {
+    expect(detectStereoSideByCharDiff('camL.mp4', 'camR.mp4'))
+      .toEqual({ stem: 'cam', leftFirst: true });
+    expect(detectStereoSideByCharDiff('camR.mp4', 'camL.mp4'))
+      .toEqual({ stem: 'cam', leftFirst: false });
+  });
+
+  it('ignores differences that are not L/R', () => {
+    expect(detectStereoSideByCharDiff('camA.mp4', 'camB.mp4')).toBeNull();
+  });
+
+  it('ignores names differing in more than one character', () => {
+    expect(detectStereoSideByCharDiff('camLL.mp4', 'camRR.mp4')).toBeNull();
+  });
+});
+
+describe('pairStereoNames', () => {
+  it('pairs left and right folders', () => {
+    const result = names(['left', 'right']);
+    expect(result.pairs).toEqual([{ stem: '', left: 'left', right: 'right' }]);
+    expect(result.unpaired).toEqual([]);
+  });
+
+  it('pairs multiple sibling video pairs by stem', () => {
+    const result = names([
+      'dive01_left.mp4', 'dive01_right.mp4', 'dive02_left.mp4', 'dive02_right.mp4',
+    ]);
+    expect(result.pairs).toEqual([
+      { stem: 'dive01', left: 'dive01_left.mp4', right: 'dive01_right.mp4' },
+      { stem: 'dive02', left: 'dive02_left.mp4', right: 'dive02_right.mp4' },
+    ]);
+    expect(result.unpaired).toEqual([]);
+  });
+
+  it('pairs across differing extensions and marker spellings', () => {
+    const result = names(['run_L.mp4', 'run_r.avi']);
+    expect(result.pairs).toEqual([{ stem: 'run', left: 'run_L.mp4', right: 'run_r.avi' }]);
+  });
+
+  it('falls back to single character difference', () => {
+    const result = names(['camL.mp4', 'camR.mp4']);
+    expect(result.pairs).toEqual([{ stem: 'cam', left: 'camL.mp4', right: 'camR.mp4' }]);
+  });
+
+  it('leaves a lone side unpaired', () => {
+    const result = names(['dive01_left.mp4', 'dive02_right.mp4']);
+    expect(result.pairs).toEqual([]);
+    expect(result.unpaired).toEqual(['dive01_left.mp4', 'dive02_right.mp4']);
+  });
+
+  it('leaves duplicate sides for one stem unpaired', () => {
+    const result = names(['a_left.mp4', 'a_l.mp4', 'a_right.mp4']);
+    expect(result.pairs).toEqual([]);
+    expect(result.unpaired).toHaveLength(3);
+  });
+
+  it('does not pair EO/IR style folders', () => {
+    const result = names(['eo', 'ir']);
+    expect(result.pairs).toEqual([]);
+    expect(result.unpaired).toEqual(['eo', 'ir']);
+  });
+});
diff --git a/client/dive-common/stereoPairing.ts b/client/dive-common/stereoPairing.ts
new file mode 100644
index 000000000..4e82bfb4d
--- /dev/null
+++ b/client/dive-common/stereoPairing.ts
@@ -0,0 +1,175 @@
+/**
+ * Left/right pairing for stereo batch import.
+ *
+ * Recognizes l / left / r / right markers in folder and video file names and
+ * pairs names that are otherwise identical, so `dive01_L.mp4` + `dive01_R.mp4`
+ * or `left/` + `right/` resolve to one stereo dataset.
+ */
+
+export type StereoSide = 'left' | 'right';
+
+const LEFT_TOKENS = new Set(['l', 'left']);
+const RIGHT_TOKENS = new Set(['r', 'right']);
+
+/** Name separators that delimit a side marker token. */
+const DELIMITERS = /[_\-.\s]+/;
+
+/** Drop a trailing file extension; names without one pass through. */
+export function stripExtension(name: string): string {
+  const index = name.lastIndexOf('.');
+  return index > 0 ? name.slice(0, index) : name;
+}
+
+export interface StereoSideMatch {
+  /** Name with the side marker removed; the pairing key. */
+  stem: string;
+  side: StereoSide;
+}
+
+/**
+ * Detect a delimited l/left/r/right token. Requires exactly one such token, so
+ * `cam_ir` (ends in "r" but tokenizes to cam + ir) and `left_right` are misses.
+ */
+export function detectStereoSideToken(name: string): StereoSideMatch | null {
+  const parts = stripExtension(name).split(DELIMITERS).filter(Boolean);
+  const matched: number[] = [];
+  parts.forEach((part, index) => {
+    const lower = part.toLowerCase();
+    if (LEFT_TOKENS.has(lower) || RIGHT_TOKENS.has(lower)) {
+      matched.push(index);
+    }
+  });
+  if (matched.length !== 1) {
+    return null;
+  }
+  const index = matched[0];
+  return {
+    stem: parts.filter((_, i) => i !== index).join('_'),
+    side: LEFT_TOKENS.has(parts[index].toLowerCase()) ? 'left' : 'right',
+  };
+}
+
+export interface StereoCharDiff {
+  /** Shared name with the differing character removed. */
+  stem: string;
+  /** Which of the two inputs is the left camera. */
+  leftFirst: boolean;
+}
+
+/**
+ * Pair two names that differ at exactly one character where that character is
+ * L/R, covering markers glued to the name (`camL.mp4` / `camR.mp4`).
+ */
+export function detectStereoSideByCharDiff(a: string, b: string): StereoCharDiff | null {
+  const baseA = stripExtension(a);
+  const baseB = stripExtension(b);
+  if (baseA.length !== baseB.length || baseA === baseB) {
+    return null;
+  }
+  let diffIndex = -1;
+  for (let i = 0; i < baseA.length; i += 1) {
+    if (baseA[i] !== baseB[i]) {
+      if (diffIndex !== -1) {
+        return null;
+      }
+      diffIndex = i;
+    }
+  }
+  if (diffIndex === -1) {
+    return null;
+  }
+  const charA = baseA[diffIndex].toLowerCase();
+  const charB = baseB[diffIndex].toLowerCase();
+  const stem = baseA.slice(0, diffIndex) + baseA.slice(diffIndex + 1);
+  if (charA === 'l' && charB === 'r') {
+    return { stem, leftFirst: true };
+  }
+  if (charA === 'r' && charB === 'l') {
+    return { stem, leftFirst: false };
+  }
+  return null;
+}
+
+export interface StereoPair<T> {
+  /** Shared name with the side marker removed; empty when the names are bare left/right. */
+  stem: string;
+  left: T;
+  right: T;
+}
+
+export interface StereoPairingResult<T> {
+  pairs: StereoPair<T>[];
+  unpaired: T[];
+}
+
+/**
+ * Pair a list of folder or video names into stereo pairs. Delimited markers are
+ * matched first; whatever is left over is matched by single-character L/R
+ * difference. A name that could join more than one pair is left unpaired.
+ */
+export function pairStereoNames<T>(
+  items: T[],
+  getName: (item: T) => string,
+): StereoPairingResult<T> {
+  const pairs: StereoPair<T>[] = [];
+  const consumed = new Set<T>();
+
+  const byStem = new Map<string, { left: T[]; right: T[] }>();
+  items.forEach((item) => {
+    const match = detectStereoSideToken(getName(item));
+    if (!match) {
+      return;
+    }
+    const group = byStem.get(match.stem) ?? { left: [], right: [] };
+    group[match.side].push(item);
+    byStem.set(match.stem, group);
+  });
+
+  // Sorted for deterministic output regardless of directory listing order.
+  [...byStem.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .forEach(([stem, group]) => {
+      if (group.left.length !== 1 || group.right.length !== 1) {
+        return;
+      }
+      pairs.push({ stem, left: group.left[0], right: group.right[0] });
+      consumed.add(group.left[0]);
+      consumed.add(group.right[0]);
+    });
+
+  const remaining = items.filter((item) => !consumed.has(item));
+  const charPairs: { stem: string; left: T; right: T }[] = [];
+  const ambiguous = new Set<T>();
+  for (let i = 0; i < remaining.length; i += 1) {
+    for (let j = i + 1; j < remaining.length; j += 1) {
+      const diff = detectStereoSideByCharDiff(getName(remaining[i]), getName(remaining[j]));
+      if (diff) {
+        const [left, right] = diff.leftFirst
+          ? [remaining[i], remaining[j]]
+          : [remaining[j], remaining[i]];
+        // A name matching more than one partner is too ambiguous to guess at.
+        if (charPairs.some((pair) => pair.left === left || pair.right === left
+          || pair.left === right || pair.right === right)) {
+          ambiguous.add(left);
+          ambiguous.add(right);
+        } else {
+          charPairs.push({ stem: diff.stem, left, right });
+        }
+      }
+    }
+  }
+
+  charPairs.forEach((pair) => {
+    if (ambiguous.has(pair.left) || ambiguous.has(pair.right)) {
+      return;
+    }
+    pairs.push(pair);
+    consumed.add(pair.left);
+    consumed.add(pair.right);
+  });
+
+  return {
+    pairs,
+    unpaired: items.filter((item) => !consumed.has(item)),
+  };
+}
diff --git a/client/platform/desktop/backend/ipcService.ts b/client/platform/desktop/backend/ipcService.ts
index b546ac1cc..ac74884e5 100644
--- a/client/platform/desktop/backend/ipcService.ts
+++ b/client/platform/desktop/backend/ipcService.ts
@@ -24,6 +24,7 @@ import win32 from './native/windows';
 import * as common from './native/common';
 import beginMultiCamImport from './native/multiCamImport';
 import scanMultiCamBatch from './native/multiCollectImport';
+import scanStereoBatch from './native/stereoCollectImport';
 import settings from './state/settings';
 import { listen } from './server';
 import {
@@ -239,6 +240,11 @@ export default function register() {
     return ret;
   });
 
+  ipcMain.handle('scan-stereo-batch', async (event, { path: rootPath }: { path: string }) => {
+    const ret = await scanStereoBatch(rootPath);
+    return ret;
+  });
+
   ipcMain.handle('import-annotation', async (event, {
     id, path, additive, additivePrepend,
   }: { id: string; path: string; additive: boolean; additivePrepend: string }) => {
diff --git a/client/platform/desktop/backend/native/common.ts b/client/platform/desktop/backend/native/common.ts
index 5a0b904bb..dd942a644 100644
--- a/client/platform/desktop/backend/native/common.ts
+++ b/client/platform/desktop/backend/native/common.ts
@@ -1971,6 +1971,7 @@ export {
   saveAttributes,
   saveAttributeTrackFilters,
   findImagesInFolder,
+  isVideoFilePath,
   listImmediateSubfolders,
   listParentFolderCameras,
   resolveMulticamCameraSourcePath,
diff --git a/client/platform/desktop/backend/native/stereoCollectImport.spec.ts b/client/platform/desktop/backend/native/stereoCollectImport.spec.ts
new file mode 100644
index 000000000..62f4fefa5
--- /dev/null
+++ b/client/platform/desktop/backend/native/stereoCollectImport.spec.ts
@@ -0,0 +1,190 @@
+import mockfs from 'mock-fs';
+import { Console } from 'console';
+
+// https://github.com/tschaub/mock-fs/issues/234
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const console = new Console(process.stdout, process.stderr);
+
+vi.mock('fs-extra', async () => {
+  const actual = await vi.importActual<typeof import('fs-extra')>('fs-extra');
+  const fsNode = await import('node:fs');
+  const existsByStat = (targetPath: import('node:fs').PathLike) => {
+    try {
+      fsNode.statSync(targetPath);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  const patchedDefault = {
+    ...actual.default,
+    existsSync: existsByStat,
+    pathExistsSync: existsByStat,
+  };
+
+  return {
+    ...actual,
+    default: patchedDefault,
+    existsSync: existsByStat,
+    pathExistsSync: existsByStat,
+  };
+});
+
+vi.mock('./mediaJobs', () => ({
+  checkMedia: vi.fn(() => Promise.resolve({
+    websafe: true,
+    originalFpsString: '30/1',
+    originalFps: 30,
+    videoDimensions: { width: 1920, height: 1080 },
+  })),
+}));
+
+// eslint-disable-next-line import/first
+import scanStereoBatch from './stereoCollectImport';
+// eslint-disable-next-line import/first
+import beginMultiCamImport from './multiCamImport';
+
+const frames = (count: number, prefix = 'frame') => {
+  const files: Record<string, string> = {};
+  for (let i = 0; i < count; i += 1) {
+    files[`${prefix}_${String(i).padStart(4, '0')}.png`] = '';
+  }
+  return files;
+};
+
+afterEach(() => {
+  mockfs.restore();
+});
+
+describe('native.stereoCollectImport', () => {
+  it('resolves left/right camera folders per collect', async () => {
+    mockfs({
+      '/survey': {
+        fl01: { left: frames(3), right: frames(3) },
+        fl02: { left: frames(2), right: frames(2) },
+      },
+    });
+    const result = await scanStereoBatch('/survey');
+    expect(result.problems).toEqual([]);
+    expect(result.cameraNames).toEqual(['left', 'right']);
+    expect(result.collects.map((collect) => collect.name)).toEqual(['fl01', 'fl02']);
+    expect(result.collects[0].importArgs?.sourceList.left.sourcePath)
+      .toBe('/survey/fl01/left');
+  });
+
+  it('resolves marker suffixed camera folders', async () => {
+    mockfs({
+      '/survey': {
+        fl01: { cam_L: frames(2), cam_R: frames(2) },
+      },
+    });
+    const result = await scanStereoBatch('/survey');
+    expect(result.collects[0].importArgs?.sourceList.left.sourcePath)
+      .toBe('/survey/fl01/cam_L');
+  });
+
+  it('falls back to listing order for two unnamed camera folders', async () => {
+    mockfs({
+      '/survey': {
+        fl01: { camA: frames(2), camB: frames(2) },
+      },
+    });
+    const result = await scanStereoBatch('/survey');
+    expect(result.collects[0].importArgs?.sourceList.left.sourcePath)
+      .toBe('/survey/fl01/camA');
+    expect(result.collects[0].warnings.join(' ')).toContain('do not identify sides');
+  });
+
+  it('errors when no left/right pair can be found', async () => {
+    mockfs({
+      '/survey': {
+        fl01: { EO: frames(2), IR: frames(2), UV: frames(2) },
+      },
+    });
+    const result = await scanStereoBatch('/survey');
+    expect(result.collects[0].importArgs).toBeNull();
+    expect(result.problems.join(' ')).toContain('No stereo datasets found');
+  });
+
+  it('pairs sibling videos in the root', async () => {
+    mockfs({
+      '/survey': {
+        'dive01_left.mp4': '',
+        'dive01_right.mp4': '',
+        'dive02_L.mp4': '',
+        'dive02_R.mp4': '',
+      },
+    });
+    const result = await scanStereoBatch('/survey');
+    expect(result.problems).toEqual([]);
+    expect(result.collects.map((collect) => collect.name)).toEqual(['dive01', 'dive02']);
+    expect(result.collects[0].importArgs?.type).toBe('video');
+  });
+
+  it('pairs sibling image folders in the root', async () => {
+    mockfs({
+      '/survey': {
+        run_L: frames(4),
+        run_R: frames(4),
+      },
+    });
+    const result = await scanStereoBatch('/survey');
+    expect(result.collects).toHaveLength(1);
+    expect(result.collects[0].name).toBe('run');
+    expect(result.collects[0].importArgs?.sourceList.right.sourcePath).toBe('/survey/run_R');
+  });
+
+  it('attaches a calibration file found next to the cameras', async () => {
+    mockfs({
+      '/survey': {
+        'calibration.npz': '',
+        fl01: { left: frames(2), right: frames(2) },
+      },
+    });
+    const result = await scanStereoBatch('/survey');
+    expect(result.collects[0].importArgs?.calibrationFile).toBe('/survey/calibration.npz');
+  });
+
+  it('produces args that import as a stereo dataset', async () => {
+    mockfs({
+      '/survey': {
+        fl01: { left: frames(2), right: frames(2) },
+      },
+    });
+    const result = await scanStereoBatch('/survey');
+    const { importArgs } = result.collects[0];
+    expect(importArgs).not.toBeNull();
+    if (!importArgs) {
+      return;
+    }
+    const imported = await beginMultiCamImport(importArgs);
+    expect(imported.jsonConfig.name).toBe('fl01');
+    expect(imported.jsonConfig.subType).toBe('stereo');
+    expect(Object.keys(imported.jsonConfig.multiCam?.cameras ?? {})).toEqual(['left', 'right']);
+    expect(imported.jsonConfig.multiCam?.defaultDisplay).toBe('left');
+    expect(imported.jsonConfig.multiCam?.cameras.left.originalBasePath)
+      .toBe('/survey/fl01/left');
+  });
+
+  it('imports a root level video pair as a stereo dataset', async () => {
+    mockfs({
+      '/survey': {
+        'dive01_left.mp4': '',
+        'dive01_right.mp4': '',
+      },
+    });
+    const result = await scanStereoBatch('/survey');
+    const { importArgs } = result.collects[0];
+    expect(importArgs).not.toBeNull();
+    if (!importArgs) {
+      return;
+    }
+    const imported = await beginMultiCamImport(importArgs);
+    expect(imported.jsonConfig.subType).toBe('stereo');
+    expect(imported.jsonConfig.multiCam?.cameras.left.originalVideoFile)
+      .toBe('dive01_left.mp4');
+    expect(imported.jsonConfig.multiCam?.cameras.right.originalVideoFile)
+      .toBe('dive01_right.mp4');
+  });
+});
diff --git a/client/platform/desktop/backend/native/stereoCollectImport.ts b/client/platform/desktop/backend/native/stereoCollectImport.ts
new file mode 100644
index 000000000..9142f696d
--- /dev/null
+++ b/client/platform/desktop/backend/native/stereoCollectImport.ts
@@ -0,0 +1,82 @@
+/**
+ * Batch stereo import scanner (desktop filesystem backend).
+ */
+import npath from 'path';
+import fs from 'fs-extra';
+import { CollectSubfolderScan } from 'dive-common/multiCamBatchScan';
+import {
+  StereoBatchRawScan,
+  StereoCollectRawScan,
+  StereoVideoScan,
+  scanStereoBatchFromScan,
+} from 'dive-common/stereoBatchScan';
+import {
+  findImagesInFolder,
+  isVideoFilePath,
+  listImmediateSubfolders,
+} from './common';
+import { findParentFolderCalibrationFile } from './datasetCalibration';
+
+async function listVideoFiles(folderPath: string): Promise<StereoVideoScan[]> {
+  const entries = await fs.readdir(folderPath, { withFileTypes: true });
+  return entries
+    .filter((entry) => entry.isFile() && !entry.name.startsWith('.'))
+    .filter((entry) => isVideoFilePath(entry.name))
+    .map((entry) => ({ name: entry.name, path: npath.join(folderPath, entry.name) }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+async function scanCollectSubfolders(collectPath: string) {
+  const subfolderNames = await listImmediateSubfolders(collectPath);
+  const subfolders = new Map<string, CollectSubfolderScan>();
+  for (let i = 0; i < subfolderNames.length; i += 1) {
+    const folderName = subfolderNames[i];
+    const subfolderPath = npath.join(collectPath, folderName);
+    // eslint-disable-next-line no-await-in-loop
+    const entryCount = (await fs.readdir(subfolderPath)).length;
+    // eslint-disable-next-line no-await-in-loop
+    const found = await findImagesInFolder(subfolderPath);
+    subfolders.set(folderName.toLowerCase(), {
+      folderName,
+      path: subfolderPath,
+      entryCount,
+      imageCount: found.imagePaths.length,
+    });
+  }
+  return subfolders;
+}
+
+async function scanStereoBatch(rootPath: string) {
+  const collectNames = (await listImmediateSubfolders(rootPath))
+    .sort((a, b) => a.localeCompare(b));
+
+  const collects: StereoCollectRawScan[] = [];
+  for (let i = 0; i < collectNames.length; i += 1) {
+    const name = collectNames[i];
+    const collectPath = npath.join(rootPath, name);
+    collects.push({
+      name,
+      path: collectPath,
+      // eslint-disable-next-line no-await-in-loop
+      subfolders: await scanCollectSubfolders(collectPath),
+      // eslint-disable-next-line no-await-in-loop
+      videoFiles: await listVideoFiles(collectPath),
+      // Images directly here make this folder one camera of a root level pair.
+      // eslint-disable-next-line no-await-in-loop
+      imageCount: (await findImagesInFolder(collectPath)).imagePaths.length,
+      // eslint-disable-next-line no-await-in-loop
+      calibrationFile: await findParentFolderCalibrationFile(collectPath),
+    });
+  }
+
+  const raw: StereoBatchRawScan = {
+    rootPath,
+    collects,
+    rootVideoFiles: await listVideoFiles(rootPath),
+    rootCalibrationFile: await findParentFolderCalibrationFile(rootPath),
+  };
+
+  return scanStereoBatchFromScan(raw);
+}
+
+export default scanStereoBatch;
diff --git a/client/platform/desktop/frontend/api.ts b/client/platform/desktop/frontend/api.ts
index a166c1be2..85ddffd19 100644
--- a/client/platform/desktop/frontend/api.ts
+++ b/client/platform/desktop/frontend/api.ts
@@ -254,6 +254,10 @@ function scanMultiCamBatch(path: string): Promise<MultiCamBatchScanResult> {
   return window.diveDesktop.invoke('scan-multicam-batch', { path });
 }
 
+function scanStereoBatch(path: string): Promise<MultiCamBatchScanResult> {
+  return window.diveDesktop.invoke('scan-stereo-batch', { path });
+}
+
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 function importAnnotationFile(id: string, path: string, _htmlFile = undefined, additive = false, additivePrepend = ''): Promise<boolean | string[]> {
   return window.diveDesktop.invoke('import-annotation', {
@@ -754,6 +758,7 @@ export {
   importAnnotationFile,
   importMultiCam,
   scanMultiCamBatch,
+  scanStereoBatch,
   openLink,
   nvidiaSmi,
   cancelJob,
diff --git a/client/platform/desktop/frontend/components/ImportStereoBatchDialog.vue b/client/platform/desktop/frontend/components/ImportStereoBatchDialog.vue
new file mode 100644
index 000000000..14bad156a
--- /dev/null
+++ b/client/platform/desktop/frontend/components/ImportStereoBatchDialog.vue
@@ -0,0 +1,65 @@
+<script lang="ts">
+import { defineComponent } from 'vue';
+import ImportMultiCamBatchDialog from 'dive-common/components/ImportMultiCamBatchDialog.vue';
+import { MultiCamBatchCollect } from 'dive-common/multiCamBatchScan';
+import * as api from '../api';
+import { setRecents } from '../store/dataset';
+
+const description = (
+  'Select a top-level folder of stereo datasets. Every dataset must resolve to a left '
+  + 'and a right camera; anything that does not is listed and skipped. Camera folders or '
+  + 'videos named with l / left and r / right markers are paired by name, a collect folder '
+  + 'holding exactly two camera folders or videos is paired in listing order, and sibling '
+  + 'folders or videos in the root that differ only by an L/R marker each become one '
+  + 'dataset. Calibration files next to the cameras are attached automatically.'
+);
+
+export default defineComponent({
+  name: 'DesktopImportStereoBatchDialog',
+  components: { ImportMultiCamBatchDialog },
+
+  setup() {
+    async function chooseAndScan() {
+      const ret = await api.openFromDisk('image-sequence', true);
+      if (ret.canceled || !ret.filePaths?.length) {
+        return null;
+      }
+      return api.scanStereoBatch(ret.filePaths[0]);
+    }
+
+    async function importCollect(collect: MultiCamBatchCollect, datasetName: string) {
+      if (!collect.importArgs) {
+        return undefined;
+      }
+      const importPayload = await api.importMultiCam({
+        ...collect.importArgs,
+        datasetName,
+      });
+      const conversionArgs = await api.finalizeImport(importPayload);
+      if (conversionArgs.mediaList.length > 0) {
+        await api.convert(conversionArgs);
+      }
+      const recentsMeta = await api.loadMetadata(conversionArgs.meta.id);
+      setRecents(recentsMeta);
+      // Batch imports skip the confirmation dialog that normally shows these.
+      return importPayload.importWarnings;
+    }
+
+    return {
+      chooseAndScan,
+      importCollect,
+      description,
+    };
+  },
+});
+</script>
+
+<template>
+  <ImportMultiCamBatchDialog
+    title="Batch Stereo Import"
+    :description="description"
+    :choose-and-scan="chooseAndScan"
+    :import-collect="importCollect"
+    @abort="$emit('abort')"
+  />
+</template>
diff --git a/client/platform/desktop/frontend/components/Recent.vue b/client/platform/desktop/frontend/components/Recent.vue
index cd88cef4b..9ef007f33 100644
--- a/client/platform/desktop/frontend/components/Recent.vue
+++ b/client/platform/desktop/frontend/components/Recent.vue
@@ -32,6 +32,7 @@ import NavigationBar from './NavigationBar.vue';
 import ImportDialog from './ImportDialog.vue';
 import BulkImportDialog from './BulkImportDialog.vue';
 import ImportMultiCamBatchDialog from './ImportMultiCamBatchDialog.vue';
+import ImportStereoBatchDialog from './ImportStereoBatchDialog.vue';
 
 export default defineComponent({
   components: {
@@ -43,6 +44,7 @@ export default defineComponent({
     NavigationBar,
     ImportMultiCamDialog,
     ImportMultiCamBatchDialog,
+    ImportStereoBatchDialog,
     TooltipBtn,
   },
 
@@ -50,6 +52,7 @@ export default defineComponent({
     const router = useRouter();
     const importMultiCamDialog = ref(false);
     const importMultiCamBatchDialog = ref(false);
+    const importStereoBatchDialog = ref(false);
     const pendingImportPayload: Ref<DesktopMediaImportResponse[] | null> = ref(null);
     const bulkImport = ref(false);
     const searchText: Ref<string | null> = ref('');
@@ -273,6 +276,7 @@ export default defineComponent({
       importing,
       importMultiCamDialog,
       importMultiCamBatchDialog,
+      importStereoBatchDialog,
       headers,
       upgradedVersion,
       downgradedVersion,
@@ -327,6 +331,18 @@ export default defineComponent({
         @abort="importMultiCamBatchDialog = false"
       />
     </v-dialog>
+    <v-dialog
+      :value="importStereoBatchDialog"
+      persistent
+      overlay-opacity="0.95"
+      max-width="80%"
+      width="1000"
+    >
+      <ImportStereoBatchDialog
+        v-if="importStereoBatchDialog"
+        @abort="importStereoBatchDialog = false"
+      />
+    </v-dialog>
     <v-dialog
       :value="pendingImportPayload !== null"
       persistent
@@ -426,8 +442,10 @@ export default defineComponent({
               open-type="bulk"
               class="my-3"
               :bulk-import="true"
+              :stereo-batch-import="true"
               @open="open($event)"
               @multi-cam-batch="importMultiCamBatchDialog = true"
+              @stereo-batch="importStereoBatchDialog = true"
             />
             <ImportButton
               name="Open Image Sequence"

From 5d4dfba5a8dae8c35129996608729ec19c7ab348 Mon Sep 17 00:00:00 2001
From: Matt Dawkins <matt.dawkins@kitware.com>
Date: Fri, 7 Aug 2026 15:30:22 -0400
Subject: [PATCH 5/7] Rename video From File to Single File and order Stereo
 before Multi Camera

---
 client/dive-common/components/ImportButton.vue | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/client/dive-common/components/ImportButton.vue b/client/dive-common/components/ImportButton.vue
index 3c21b4972..3b1d422b5 100644
--- a/client/dive-common/components/ImportButton.vue
+++ b/client/dive-common/components/ImportButton.vue
@@ -149,26 +149,26 @@ export default defineComponent({
             </v-list-item-content>
           </v-list-item>
           <v-list-item
+            v-if="stereoBatchImport"
             style="align-items':'center"
-            @click="$emit('multi-cam-batch')"
+            @click="$emit('stereo-batch')"
           >
             <v-list-item-icon>
-              <v-icon>mdi-folder-multiple-image</v-icon>
+              <v-icon>mdi-binoculars</v-icon>
             </v-list-item-icon>
             <v-list-item-content>
-              <v-list-item-title>Multi Camera</v-list-item-title>
+              <v-list-item-title>Stereo</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
           <v-list-item
-            v-if="stereoBatchImport"
             style="align-items':'center"
-            @click="$emit('stereo-batch')"
+            @click="$emit('multi-cam-batch')"
           >
             <v-list-item-icon>
-              <v-icon>mdi-binoculars</v-icon>
+              <v-icon>mdi-folder-multiple-image</v-icon>
             </v-list-item-icon>
             <v-list-item-content>
-              <v-list-item-title>Stereo</v-list-item-title>
+              <v-list-item-title>Multi Camera</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
         </v-list>
@@ -197,7 +197,7 @@ export default defineComponent({
               <v-icon>mdi-file-video</v-icon>
             </v-list-item-icon>
             <v-list-item-content>
-              <v-list-item-title>From File</v-list-item-title>
+              <v-list-item-title>Single File</v-list-item-title>
             </v-list-item-content>
           </v-list-item>
           <v-list-item

From 620162247f57520f66dc2634708515c2ab720907 Mon Sep 17 00:00:00 2001
From: Bryon Lewis <Bryon.Lewis@kitware.com>
Date: Mon, 10 Aug 2026 15:18:09 -0400
Subject: [PATCH 6/7] use load config for configuration file

---
 .../desktop/frontend/components/ImportStereoBatchDialog.vue     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/client/platform/desktop/frontend/components/ImportStereoBatchDialog.vue b/client/platform/desktop/frontend/components/ImportStereoBatchDialog.vue
index 14bad156a..6b8da1dc0 100644
--- a/client/platform/desktop/frontend/components/ImportStereoBatchDialog.vue
+++ b/client/platform/desktop/frontend/components/ImportStereoBatchDialog.vue
@@ -39,7 +39,7 @@ export default defineComponent({
       if (conversionArgs.mediaList.length > 0) {
         await api.convert(conversionArgs);
       }
-      const recentsMeta = await api.loadMetadata(conversionArgs.meta.id);
+      const recentsMeta = await api.loadConfig(conversionArgs.meta.id);
       setRecents(recentsMeta);
       // Batch imports skip the confirmation dialog that normally shows these.
       return importPayload.importWarnings;

From a9f9ab73d58e0fca77ebd916df02392ee3dcfb13 Mon Sep 17 00:00:00 2001
From: Bryon Lewis <Bryon.Lewis@kitware.com>
Date: Mon, 10 Aug 2026 15:23:31 -0400
Subject: [PATCH 7/7] handling name conflicts

---
 client/dive-common/stereoBatchScan.spec.ts | 15 +++++++++++++++
 client/dive-common/stereoBatchScan.ts      | 20 +++++++++++++++++++-
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/client/dive-common/stereoBatchScan.spec.ts b/client/dive-common/stereoBatchScan.spec.ts
index 31dd9185d..76df28672 100644
--- a/client/dive-common/stereoBatchScan.spec.ts
+++ b/client/dive-common/stereoBatchScan.spec.ts
@@ -185,4 +185,19 @@ describe('scanStereoBatchFromScan', () => {
     expect(result.collects.find((c) => c.name === 'good')?.importArgs).not.toBeNull();
     expect(result.collects.find((c) => c.name === 'bad')?.importArgs).toBeNull();
   });
+
+  it('suffixes collect name and datasetName when a root pair already took the stem', () => {
+    const result = scan({
+      rootVideoFiles: [
+        { name: 'dive01_left.mp4', path: '/survey/dive01_left.mp4' },
+        { name: 'dive01_right.mp4', path: '/survey/dive01_right.mp4' },
+      ],
+      collects: [collect('dive01', [['left', 4], ['right', 4]])],
+    });
+    const names = result.collects.map((c) => c.name);
+    expect(names).toContain('dive01');
+    expect(names).toContain('dive01_2');
+    const suffixed = result.collects.find((c) => c.name === 'dive01_2');
+    expect(suffixed?.importArgs?.datasetName).toBe('dive01_2');
+  });
 });
diff --git a/client/dive-common/stereoBatchScan.ts b/client/dive-common/stereoBatchScan.ts
index a1cd7a9e0..d63f9133b 100644
--- a/client/dive-common/stereoBatchScan.ts
+++ b/client/dive-common/stereoBatchScan.ts
@@ -255,6 +255,24 @@ function uniqueName(name: string, taken: Set<string>): string {
   return unique;
 }
 
+/** Suffix the collect display name and keep importArgs.datasetName in sync. */
+function withUniqueName(
+  collect: MultiCamBatchCollect,
+  taken: Set<string>,
+): MultiCamBatchCollect {
+  const name = uniqueName(collect.name, taken);
+  if (name === collect.name) {
+    return collect;
+  }
+  return {
+    ...collect,
+    name,
+    importArgs: collect.importArgs
+      ? { ...collect.importArgs, datasetName: name }
+      : null,
+  };
+}
+
 /**
  * Build a stereo batch scan result from a pre-scanned root folder.
  */
@@ -318,7 +336,7 @@ export function scanStereoBatchFromScan(raw: StereoBatchRawScan): MultiCamBatchS
     .filter((collect) => !pairedFolders.has(collect))
     .forEach((collect) => {
       const resolved = resolveCollect(collect, rootCalibrationFile);
-      collects.push({ ...resolved, name: uniqueName(resolved.name, takenNames) });
+      collects.push(withUniqueName(resolved, takenNames));
     });
 
   if (!raw.collects.length && !rootVideos.length) {