diff --git a/client/dive-common/apispec.ts b/client/dive-common/apispec.ts
index 43c146267..aee4f03ab 100644
--- a/client/dive-common/apispec.ts
+++ b/client/dive-common/apispec.ts
@@ -21,6 +21,7 @@ import type {
   ScoringResultSummary,
   ScoringSourceOptions,
 } from 'dive-common/scoring/types';
+import type { TaxonomySources } from './worms';
 
 type DatasetType = 'image-sequence' | 'video' | 'multi' | 'large-image';
 type MultiTrackRecord = Record<string, TrackData>;
@@ -304,6 +305,7 @@ type DatasetInfoFields = Record<string, unknown>;
  * The parts of dataset config a user should be able to modify.
  */
 interface DatasetConfigMutable {
+  taxonomySources?: TaxonomySources;
   typeHierarchy?: Record<string, string> | null;
   customTypeStyling?: Record<string, CustomStyle>;
   customGroupStyling?: Record<string, CustomStyle>;
@@ -332,7 +334,7 @@ interface DatasetConfigMutable {
   cameraRoles?: Record<string, CameraRole>;
   error?: string;
 }
-const DatasetConfigMutableKeys = ['attributes', 'confidenceFilters', 'timeFilters', 'imageEnhancements', 'customTypeStyling', 'customGroupStyling', 'attributeTrackFilters', 'datasetInfo', 'cameraHomographies', 'cameraCorrespondences', 'cameraTransformTypes', 'cameraRegistrationSource', 'typeHierarchy', 'cameraRoles'];
+const DatasetConfigMutableKeys = ['attributes', 'confidenceFilters', 'timeFilters', 'imageEnhancements', 'customTypeStyling', 'customGroupStyling', 'attributeTrackFilters', 'datasetInfo', 'cameraHomographies', 'cameraCorrespondences', 'cameraTransformTypes', 'cameraRegistrationSource', 'typeHierarchy', 'taxonomySources', 'cameraRoles'];
 /**
  * Cross-dataset color/style overrides, reused across every dataset when the
  * "shared" color scope is enabled (see clientSettings.typeSettings.colorScope).
diff --git a/client/dive-common/categoryImport.spec.ts b/client/dive-common/categoryImport.spec.ts
new file mode 100644
index 000000000..0c60499ce
--- /dev/null
+++ b/client/dive-common/categoryImport.spec.ts
@@ -0,0 +1,91 @@
+import { parseCategoryFile } from './categoryImport';
+
+const parseJson = (value: unknown) => parseCategoryFile(JSON.stringify(value), 'categories.json');
+
+describe('category file import', () => {
+  it('imports COCO categories without importing annotations and preserves hierarchy-only parents', () => {
+    expect(parseJson({
+      categories: [{
+        id: 2, name: 'salmon', supercategory: 'fish', parents: ['ignored'],
+      }],
+      annotations: [{ category_id: 2 }],
+    })).toEqual({ types: ['salmon'], typeHierarchy: { salmon: 'fish' }, warnings: [] });
+  });
+
+  it('accepts COCO top-level self supercategories and null supercategories', () => {
+    expect(parseJson({
+      categories: [
+        { name: 'fish', supercategory: 'fish' },
+        { name: 'animal', supercategory: null },
+        { name: 'shark', supercategory: 'fish' },
+      ],
+    })).toEqual({ types: ['fish', 'animal', 'shark'], typeHierarchy: { shark: 'fish' }, warnings: [] });
+  });
+
+  it('supports JSON strings, category objects, parents, and DIVE hierarchy maps', () => {
+    expect(parseJson(['fish', 'shark', 'fish']).types).toEqual(['fish', 'shark']);
+    expect(parseJson({ categories: [{ name: 'shark', parents: ['fish'] }], typeHierarchy: { fish: 'animal' } }))
+      .toEqual({ types: ['shark'], typeHierarchy: { shark: 'fish', fish: 'animal' }, warnings: [] });
+    expect(parseJson({ typeHierarchy: { fish: 'animal' } }).typeHierarchy).toEqual({ fish: 'animal' });
+  });
+
+  it('reads VIAME TXT comments, quoted names, synonyms, BOM, CRLF, and parent references', () => {
+    const result = parseCategoryFile('\uFEFF# labels\r\n"sea life" marine\r\n"red fish" rf :parent=marine # comment\r\nshark :parent="sea life"', 'LABELS.TXT');
+    expect(result.types).toEqual(['sea life', 'red fish', 'shark']);
+    expect(result.typeHierarchy).toEqual({ 'red fish': 'sea life', shark: 'sea life' });
+    expect(result.warnings).toHaveLength(1);
+  });
+
+  it('reads VIAME CSV quoted commas, escaped quotes, newlines, and multiword names', () => {
+    const result = parseCategoryFile('sea life,marine\r\n"fish, red",rf,:parent=marine\r\n"a ""quoted"" fish",,:parent=sea life\n"multi\nline"', 'labels.csv');
+    expect(result.types).toEqual(['sea life', 'fish, red', 'a "quoted" fish', 'multi\nline']);
+    expect(result.typeHierarchy).toEqual({ 'fish, red': 'sea life', 'a "quoted" fish': 'sea life' });
+  });
+
+  it('supports escaped TXT quotes and single quotes', () => {
+    expect(parseCategoryFile("'fish species'\n\"a \\\"fish\\\"\"", 'labels.txt').types)
+      .toEqual(['fish species', 'a "fish"']);
+  });
+
+  it('resolves JSON synonyms without creating extra types', () => {
+    const result = parseJson([{ name: 'fish', synonyms: ['f'] }, { name: 'shark', parents: ['f'] }]);
+    expect(result.types).toEqual(['fish', 'shark']);
+    expect(result.typeHierarchy).toEqual({ shark: 'fish' });
+    expect(result.warnings).toHaveLength(1);
+  });
+
+  it.each([
+    {}, { categories: {} }, { categories: null, typeHierarchy: { fish: 'animal' } }, { categories: [1] }, { categories: [{ name: ' ' }] },
+    { categories: [{ name: 'fish', id: '1' }] },
+    { categories: [{ name: 'fish', parents: 'animal' }] },
+    { categories: [{ name: 'fish', synonyms: 'f' }] },
+    { categories: [{ name: 'fish', supercategory: 4 }] },
+    { typeHierarchy: [] }, { typeHierarchy: { fish: 2 } },
+  ])('rejects malformed JSON definitions: %j', (value) => {
+    expect(() => parseJson(value)).toThrow();
+  });
+
+  it.each([
+    { categories: [{ name: 'fish', parents: ['a', 'b'] }] },
+    { categories: [{ name: 'fish', supercategory: 'a' }], typeHierarchy: { fish: 'b' } },
+    { typeHierarchy: { a: 'b', b: 'a' } },
+    { typeHierarchy: { a: 'a' } },
+    [{ name: 'fish', synonyms: ['shark'] }, 'shark'],
+    [{ name: 'fish', synonyms: ['f'] }, { name: 'shark', synonyms: ['f'] }],
+  ])('rejects ambiguous or invalid relationships: %j', (value) => {
+    expect(() => parseJson(value)).toThrow();
+  });
+
+  it.each([
+    ['"unterminated', 'txt'], ['"unterminated', 'csv'],
+    ['"fish"x', 'csv'], [',fish', 'csv'], ['fish :parent=', 'txt'],
+    ['# only comments', 'txt'], ['', 'csv'], ['[]', 'json'], ['{', 'json'], ['fish', 'xml'],
+  ])('rejects invalid or empty files (%s, %s)', (text, extension) => {
+    expect(() => parseCategoryFile(text, `labels.${extension}`)).toThrow();
+  });
+
+  it('handles prototype property names safely', () => {
+    const result = parseJson(JSON.parse('{"typeHierarchy":{"__proto__":"constructor"}}'));
+    expect(Object.entries(result.typeHierarchy!)).toEqual([['__proto__', 'constructor']]);
+  });
+});
diff --git a/client/dive-common/categoryImport.ts b/client/dive-common/categoryImport.ts
new file mode 100644
index 000000000..274a2380c
--- /dev/null
+++ b/client/dive-common/categoryImport.ts
@@ -0,0 +1,183 @@
+import type { SynonymRemap, TaxonomySources } from './worms';
+import { normalizeTypeHierarchy, TypeHierarchy } from './typeHierarchy';
+
+export interface CategoryImport {
+  types: string[];
+  taxonomySources?: TaxonomySources;
+  typeHierarchy?: TypeHierarchy;
+  /** Synonym → accepted remaps from WoRMS (shown grouped in the import preview). */
+  synonymRemaps?: SynonymRemap[];
+  warnings: string[];
+}
+
+function label(value: unknown): string {
+  if (typeof value !== 'string' || !value.trim()) {
+    throw new Error('Category names and parents must be nonempty strings.');
+  }
+  return value;
+}
+
+/** Match VIAME's label rows: TXT uses whitespace, CSV uses commas, extras are aliases. */
+function labelRows(text: string, csv: boolean): string[][] {
+  const rows: string[][] = [];
+  let row: string[] = [];
+  let field = '';
+  let quote = '';
+  let started = false;
+  let closed = false;
+  let quoted = false;
+  const finishField = () => {
+    if (csv && !quoted) field = field.replace(/[ \t]+$/, '');
+    if (started) row.push(label(field));
+    field = '';
+    started = false;
+    closed = false;
+    quoted = false;
+  };
+  const finishRow = () => {
+    finishField();
+    if (row.length) rows.push(row);
+    row = [];
+  };
+  for (let i = 0; i < text.length; i += 1) {
+    const c = text[i];
+    if (quote) {
+      if (c === quote) {
+        if (text[i + 1] === quote) {
+          field += c;
+          i += 1;
+        } else {
+          quote = '';
+          closed = true;
+        }
+      } else if (!csv && c === '\\' && [quote, '\\'].includes(text[i + 1])) {
+        i += 1;
+        field += text[i];
+      } else {
+        if (!csv && /[\r\n]/.test(c)) throw new Error('Unterminated quoted label.');
+        field += c;
+      }
+    } else if (/[\r\n]/.test(c)) {
+      if (c === '\r' && text[i + 1] === '\n') i += 1;
+      finishRow();
+    } else if (!csv && c === '#') {
+      while (i + 1 < text.length && !/[\r\n]/.test(text[i + 1])) i += 1;
+      finishRow();
+    } else if (csv && c === ',') {
+      if (!started && !row.length) throw new Error('Empty category name.');
+      finishField();
+    } else if (/\s/.test(c)) {
+      if (!csv) finishField();
+      else if (started && !closed) field += c;
+    } else if ((c === '"' || (!csv && c === "'"))
+      && (!started || (!csv && field === ':parent='))) {
+      quote = c;
+      started = true;
+      quoted = true;
+    } else {
+      if (closed) throw new Error('Expected a separator after quoted label.');
+      field += c;
+      started = true;
+    }
+  }
+  if (quote) throw new Error('Unterminated quoted label.');
+  finishRow();
+  return rows;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+/** Parse category definitions only; COCO images and annotations are deliberately ignored. */
+export function parseCategoryFile(contents: string, filename: string): CategoryImport {
+  const text = contents.replace(/^\uFEFF/, '');
+  const extension = filename.split('.').pop()?.toLowerCase();
+  const names = new Set<string>();
+  const aliases = new Map<string, string>();
+  const edges: [string, string][] = [];
+  const addAlias = (name: string, value: unknown) => {
+    const alias = label(value);
+    if (aliases.has(alias) && aliases.get(alias) !== name) {
+      throw new Error(`Synonym "${alias}" refers to multiple categories.`);
+    }
+    aliases.set(alias, name);
+  };
+  const addName = (value: unknown) => {
+    const name = label(value);
+    names.add(name);
+    return name;
+  };
+  if (extension === 'json') {
+    const doc: unknown = JSON.parse(text);
+    let categories: unknown = doc;
+    if (isObject(doc)) {
+      categories = Object.prototype.hasOwnProperty.call(doc, 'typeHierarchy') ? [] : undefined;
+      if (Object.prototype.hasOwnProperty.call(doc, 'categories')) categories = doc.categories;
+    }
+    if (!Array.isArray(categories)) {
+      throw new Error('JSON must be a category array or contain categories or typeHierarchy.');
+    }
+    categories.forEach((category: unknown) => {
+      const name = addName(isObject(category) ? category.name : category);
+      if (!isObject(category)) return;
+      if (category.id !== undefined && !Number.isInteger(category.id)) {
+        throw new Error(`Category id for "${name}" must be an integer.`);
+      }
+      if (category.synonyms !== undefined) {
+        if (!Array.isArray(category.synonyms)) throw new Error('synonyms must be an array.');
+        category.synonyms.forEach((alias) => addAlias(name, alias));
+      }
+      if (category.supercategory !== undefined && category.supercategory !== null
+        && typeof category.supercategory !== 'string') {
+        throw new Error('supercategory must be a string.');
+      }
+      if (category.supercategory) {
+        // COCO often repeats the category name to designate a top-level category.
+        if (category.supercategory !== name) edges.push([name, label(category.supercategory)]);
+      } else if (category.parents !== undefined) {
+        if (!Array.isArray(category.parents)) throw new Error('parents must be an array.');
+        category.parents.forEach((parent) => edges.push([name, label(parent)]));
+      }
+    });
+    if (isObject(doc) && doc.typeHierarchy !== undefined && doc.typeHierarchy !== null) {
+      if (!isObject(doc.typeHierarchy)) throw new Error('typeHierarchy must be a child-to-parent object.');
+      Object.entries(doc.typeHierarchy).forEach(([child, parent]) => {
+        edges.push([label(child), label(parent)]);
+      });
+    }
+  } else if (extension === 'txt' || extension === 'csv') {
+    labelRows(text, extension === 'csv').forEach(([value, ...extras]) => {
+      const name = addName(value);
+      extras.forEach((extra) => {
+        if (extra.startsWith(':parent=')) edges.push([name, label(extra.slice(8))]);
+        else addAlias(name, extra);
+      });
+    });
+  } else {
+    throw new Error('Choose a .txt, .csv, or .json category file.');
+  }
+  aliases.forEach((name, alias) => {
+    if (names.has(alias) && alias !== name) {
+      throw new Error(`Synonym "${alias}" is also a category name.`);
+    }
+  });
+  const hierarchy = new Map<string, string>();
+  edges.forEach(([rawChild, rawParent]) => {
+    const child = aliases.get(rawChild) ?? rawChild;
+    const parent = aliases.get(rawParent) ?? rawParent;
+    if (hierarchy.has(child) && hierarchy.get(child) !== parent) {
+      throw new Error(`Category "${child}" has multiple parents. DIVE supports one parent per type.`);
+    }
+    hierarchy.set(child, parent);
+  });
+  const typeHierarchy = normalizeTypeHierarchy(Object.fromEntries(hierarchy));
+  if (!names.size && !hierarchy.size) throw new Error('The file contains no categories.');
+  return {
+    types: [...names],
+    typeHierarchy,
+    warnings: aliases.size
+      ? ['Synonyms resolve parent references during import. DIVE stores canonical category names, not synonym aliases.']
+      : [],
+  };
+}
diff --git a/client/dive-common/components/BottomPanel.vue b/client/dive-common/components/BottomPanel.vue
index 0b158cfec..9d6740791 100644
--- a/client/dive-common/components/BottomPanel.vue
+++ b/client/dive-common/components/BottomPanel.vue
@@ -176,7 +176,7 @@ export default defineComponent({
       </div>
 
       <template v-if="bottomRightPanelView === 'filters'">
-        <div class="flex-grow-1 bottom-filter-list" style="overflow-y: auto; overflow-x: hidden;">
+        <div class="bottom-filter-list">
           <FilterList
             :show-empty-types="clientSettings.typeSettings.showEmptyTypes"
             :height="130"
@@ -185,13 +185,12 @@ export default defineComponent({
             :style-manager="trackStyleManager"
             :filter-controls="trackFilters"
             :disabled="disableAnnotationFilters"
-            class="fill-height"
+            class="flex-grow-1"
           >
             <template #settings>
               <TypeSettingsPanel
                 :all-types="trackFilters.allTypes.value"
                 :hierarchy-active="trackFilters.hierarchyActive.value"
-                @import-types="trackFilters.importTypes($event)"
               />
             </template>
           </FilterList>
@@ -301,6 +300,11 @@ export default defineComponent({
 }
 
 .bottom-filter-list {
+  display: flex;
+  flex-direction: column;
+  flex: 1 1 0;
+  min-height: 0;
+  overflow: hidden;
   #type-header b {
     font-size: 14px;
     font-weight: 600;
diff --git a/client/dive-common/components/CategoryImportDialog.spec.ts b/client/dive-common/components/CategoryImportDialog.spec.ts
new file mode 100644
index 000000000..e27caa311
--- /dev/null
+++ b/client/dive-common/components/CategoryImportDialog.spec.ts
@@ -0,0 +1,323 @@
+import {
+  defineComponent, h, ref, nextTick,
+} from 'vue';
+import { shallowMount } from '@vue/test-utils';
+import { clientSettings } from 'dive-common/store/settings';
+import CategoryImportDialog from './CategoryImportDialog.vue';
+
+const mocks = vi.hoisted(() => ({ apply: vi.fn(), readOnly: false }));
+vi.mock('vue-media-annotator/provides', () => ({
+  useReadOnlyMode: () => ref(mocks.readOnly),
+  useTrackFilters: () => ({
+    typeHierarchy: ref({ fish: 'animal' }),
+    importCategoryDefinitions: mocks.apply,
+  }),
+}));
+
+function mountDialog() {
+  let vm: InstanceType<typeof CategoryImportDialog> | undefined;
+  const close = vi.fn();
+  const Host = defineComponent({
+    setup: () => () => h(CategoryImportDialog, {
+      on: { close },
+      ref: (instance) => { vm = instance as InstanceType<typeof CategoryImportDialog>; },
+    }),
+  });
+  const wrapper = shallowMount(Host, { stubs: { CategoryImportDialog: false } });
+  if (!vm) throw new Error('Dialog did not mount.');
+  return { vm, wrapper, close };
+}
+
+function file(name: string, contents: string): File {
+  return { name, text: async () => contents } as File;
+}
+
+describe('category import dialog shared by web and desktop', () => {
+  beforeEach(() => {
+    mocks.apply.mockReset();
+    mocks.readOnly = false;
+    clientSettings.typeSettings.showEmptyTypes = false;
+    clientSettings.typeSettings.filterTypesByFrame = true;
+  });
+
+  it('previews file hierarchy and applies it only on Add', async () => {
+    const { vm, wrapper, close } = mountDialog();
+    await vm.selectFile(file('coco.json', '{"categories":[{"name":"shark","supercategory":"fish"}]}'));
+    expect(vm.preview.names).toEqual(['shark', 'fish']);
+    expect(vm.canImport).toBe(true);
+    expect(mocks.apply).not.toHaveBeenCalled();
+    vm.confirmImport();
+    expect(mocks.apply).toHaveBeenCalledWith(['shark'], { shark: 'fish' }, undefined);
+    expect(close).toHaveBeenCalledOnce();
+    wrapper.destroy();
+  });
+
+  it('stages WoRMS on the file page without applying until the second Add', async () => {
+    const { vm, wrapper } = mountDialog();
+    vm.source = 'worms';
+    await nextTick();
+    const taxonomySources = { 3: { aphiaId: 3, scientificName: 'shark', rank: 'Species' } };
+    vm.setWormsImport({
+      types: ['shark'], typeHierarchy: { shark: 'fish' }, taxonomySources, warnings: [],
+    });
+    expect(vm.source).toBe('file');
+    expect(vm.pastedTypes).toBe('shark');
+    expect(mocks.apply).not.toHaveBeenCalled();
+    expect(clientSettings.typeSettings.showEmptyTypes).toBe(false);
+    await nextTick();
+    expect(vm.canImport).toBe(true);
+    expect(vm.preview.tree).toEqual([
+      { name: 'fish', depth: 0, rank: undefined },
+      { name: 'shark', depth: 1, rank: 'Species' },
+    ]);
+    expect(wrapper.text()).toContain('fish');
+    expect(wrapper.text()).toContain('shark');
+    vm.confirmImport();
+    expect(mocks.apply).toHaveBeenCalledWith(['shark'], { shark: 'fish' }, taxonomySources);
+    expect(clientSettings.typeSettings.showEmptyTypes).toBe(true);
+    expect(clientSettings.typeSettings.filterTypesByFrame).toBe(false);
+    vm.source = 'file';
+    await nextTick();
+    vm.source = 'worms';
+    await nextTick();
+    expect(vm.canImport).toBe(false);
+    wrapper.destroy();
+  });
+
+  it('summarizes WoRMS synonym remaps and expands grouped details on demand', async () => {
+    const { vm, wrapper } = mountDialog();
+    vm.source = 'worms';
+    await nextTick();
+    vm.setWormsImport({
+      types: ['salmon', 'trout'],
+      warnings: ['"Seriola gigas" resolves to multiple accepted names: "Seriola dumerili", "Seriola hippos".'],
+      synonymRemaps: [
+        { original: 'old salmon', accepted: 'salmon' },
+        { original: 'Salmo old', accepted: 'salmon' },
+        { original: 'old trout', accepted: 'trout' },
+      ],
+    });
+    await nextTick();
+    expect(wrapper.text()).toContain('3 synonyms will be imported as 2 accepted names.');
+    expect(wrapper.text()).toContain('Show details');
+    expect(wrapper.text()).not.toContain('salmon ←');
+    expect(wrapper.text()).toContain('resolves to multiple accepted names');
+    vm.showSynonymDetails = true;
+    await nextTick();
+    expect(wrapper.text()).toContain('salmon ← old salmon, Salmo old');
+    expect(wrapper.text()).toContain('trout ← old trout');
+    expect(wrapper.text()).toContain('Hide details');
+    wrapper.destroy();
+  });
+
+  it('drops synonym remaps and multi-accepted warnings for pruned accepted names', async () => {
+    const { vm, wrapper } = mountDialog();
+    vm.source = 'worms';
+    await nextTick();
+    vm.setWormsImport({
+      types: ['salmon', 'trout', 'Seriola dumerili', 'Seriola hippos'],
+      warnings: [
+        'Synonyms resolve parent references during import. DIVE stores canonical category names, not synonym aliases.',
+        '"Seriola gigas" resolves to multiple accepted names: "Seriola dumerili", "Seriola hippos".',
+      ],
+      synonymRemaps: [
+        { original: 'old salmon', accepted: 'salmon' },
+        { original: 'old trout', accepted: 'trout' },
+        { original: 'Seriola gigas', accepted: 'Seriola dumerili' },
+        { original: 'Seriola gigas', accepted: 'Seriola hippos' },
+      ],
+    });
+    await nextTick();
+    vm.showSynonymDetails = true;
+    vm.pruneStagedType('salmon');
+    await nextTick();
+    expect(vm.preview.incoming?.types).toEqual(['trout', 'Seriola dumerili', 'Seriola hippos']);
+    expect(vm.preview.incoming?.synonymRemaps).toEqual([
+      { original: 'old trout', accepted: 'trout' },
+      { original: 'Seriola gigas', accepted: 'Seriola dumerili' },
+      { original: 'Seriola gigas', accepted: 'Seriola hippos' },
+    ]);
+    expect(wrapper.text()).toContain('3 synonyms will be imported as 3 accepted names.');
+    expect(wrapper.text()).not.toContain('salmon ←');
+    expect(wrapper.text()).toContain('trout ← old trout');
+    expect(wrapper.text()).toContain('resolves to multiple accepted names');
+    expect(vm.preview.incoming?.warnings).toEqual([
+      'Synonyms resolve parent references during import. DIVE stores canonical category names, not synonym aliases.',
+      '"Seriola gigas" resolves to multiple accepted names: "Seriola dumerili", "Seriola hippos".',
+    ]);
+    vm.pruneStagedType('Seriola dumerili');
+    await nextTick();
+    expect(vm.preview.incoming?.synonymRemaps).toEqual([
+      { original: 'old trout', accepted: 'trout' },
+      { original: 'Seriola gigas', accepted: 'Seriola hippos' },
+    ]);
+    expect(vm.preview.incoming?.warnings).toEqual([
+      'Synonyms resolve parent references during import. DIVE stores canonical category names, not synonym aliases.',
+    ]);
+    expect(wrapper.text()).not.toContain('resolves to multiple accepted names');
+    expect(wrapper.text()).toContain('2 synonyms will be imported as 2 accepted names.');
+    vm.pruneStagedType('trout');
+    await nextTick();
+    expect(vm.preview.incoming?.synonymRemaps).toEqual([
+      { original: 'Seriola gigas', accepted: 'Seriola hippos' },
+    ]);
+    expect(wrapper.text()).toContain('1 synonym will be imported as 1 accepted name.');
+    vm.pruneStagedType('Seriola hippos');
+    await nextTick();
+    expect(vm.preview.incoming?.types).toEqual([]);
+    expect(vm.preview.incoming?.synonymRemaps).toBeUndefined();
+    expect(vm.wormsImport).toBeNull();
+    expect(vm.showSynonymDetails).toBe(false);
+    expect(wrapper.text()).not.toContain('will be imported as');
+    wrapper.destroy();
+  });
+
+  it('prunes a middle WoRMS rank so descendants become roots and unused ancestors drop', async () => {
+    const { vm, wrapper } = mountDialog();
+    vm.source = 'worms';
+    await nextTick();
+    vm.setWormsImport({
+      types: ['something'],
+      typeHierarchy: { something: 'Animalia', Animalia: 'Biota' },
+      taxonomySources: {
+        1: { aphiaId: 1, scientificName: 'Biota', rank: 'Superdomain' },
+        2: { aphiaId: 2, scientificName: 'Animalia', rank: 'Kingdom' },
+        3: { aphiaId: 3, scientificName: 'something', rank: 'Species' },
+      },
+      warnings: [],
+    });
+    await nextTick();
+    vm.pruneStagedType('Animalia');
+    await nextTick();
+    expect(vm.preview.incoming?.typeHierarchy).toBeUndefined();
+    expect(vm.preview.incoming?.types).toEqual(['something']);
+    expect(vm.preview.tree).toEqual([
+      { name: 'something', depth: 0, rank: 'Species' },
+    ]);
+    expect(vm.preview.incoming?.taxonomySources).toEqual({
+      3: { aphiaId: 3, scientificName: 'something', rank: 'Species' },
+    });
+    expect(mocks.apply).not.toHaveBeenCalled();
+    wrapper.destroy();
+  });
+
+  it('keeps a shared ancestor when pruning one WoRMS branch', async () => {
+    const { vm, wrapper } = mountDialog();
+    vm.source = 'worms';
+    await nextTick();
+    vm.setWormsImport({
+      types: ['fish', 'oak'],
+      typeHierarchy: {
+        fish: 'Animalia', Animalia: 'Biota', oak: 'Plantae', Plantae: 'Biota',
+      },
+      warnings: [],
+    });
+    await nextTick();
+    vm.pruneStagedType('Animalia');
+    await nextTick();
+    expect(vm.preview.incoming?.typeHierarchy).toEqual({ oak: 'Plantae', Plantae: 'Biota' });
+    expect(vm.preview.incoming?.types).toEqual(['fish', 'oak']);
+    expect(vm.preview.tree.map((row) => row.name)).toEqual(['Biota', 'Plantae', 'oak', 'fish']);
+    wrapper.destroy();
+  });
+
+  it('merges staged WoRMS taxa with a pending file and survives tab changes', async () => {
+    const { vm, wrapper } = mountDialog();
+    await vm.selectFile(file('categories.json', '{"typeHierarchy":{"salmon":"fish"}}'));
+    vm.source = 'worms';
+    await nextTick();
+    vm.setWormsImport({ types: ['shark'], typeHierarchy: { shark: 'fish' }, warnings: [] });
+    await nextTick();
+    expect(vm.preview.incoming?.typeHierarchy).toEqual({ salmon: 'fish', shark: 'fish' });
+    expect(vm.preview.names).toEqual(expect.arrayContaining(['salmon', 'fish', 'shark']));
+    vm.source = 'worms';
+    await nextTick();
+    expect(vm.canImport).toBe(false);
+    vm.source = 'file';
+    await nextTick();
+    expect(vm.canImport).toBe(true);
+    expect(vm.preview.incoming?.typeHierarchy).toEqual({ salmon: 'fish', shark: 'fish' });
+    expect(mocks.apply).not.toHaveBeenCalled();
+    wrapper.destroy();
+  });
+
+  it('does not replace pending categories when a WoRMS hierarchy conflicts', async () => {
+    const { vm, wrapper } = mountDialog();
+    await vm.selectFile(file('categories.json', '{"typeHierarchy":{"shark":"fish"}}'));
+    vm.source = 'worms';
+    await nextTick();
+    vm.setWormsImport({ types: ['shark'], typeHierarchy: { shark: 'other' }, warnings: [] });
+    expect(vm.errorMessage).toContain('conflicting parents');
+    expect(vm.source).toBe('worms');
+    expect(vm.preview.incoming?.typeHierarchy).toEqual({ shark: 'fish' });
+    expect(mocks.apply).not.toHaveBeenCalled();
+    wrapper.destroy();
+  });
+
+  it('retains pasted names with spaces and trims blank or repeated lines', () => {
+    const { vm, wrapper } = mountDialog();
+    vm.pastedTypes = ' red fish \r\n\nred fish\nshark';
+    vm.confirmImport();
+    expect(mocks.apply).toHaveBeenCalledWith(['red fish', 'shark'], undefined, undefined);
+    wrapper.destroy();
+  });
+
+  it('prevents conflicting hierarchy imports and permits correction', async () => {
+    const { vm, wrapper } = mountDialog();
+    await vm.selectFile(file('labels.json', '{"typeHierarchy":{"fish":"other"}}'));
+    expect(vm.errorMessage).toContain('conflicting parents');
+    expect(vm.canImport).toBe(false);
+    vm.confirmImport();
+    expect(mocks.apply).not.toHaveBeenCalled();
+    await vm.selectFile(file('labels.txt', 'shark'));
+    expect(vm.canImport).toBe(true);
+    wrapper.destroy();
+  });
+
+  it('shows parse and read errors without applying any types', async () => {
+    const { vm, wrapper } = mountDialog();
+    await vm.selectFile(file('labels.json', '{'));
+    expect(vm.errorMessage).toBeTruthy();
+    expect(vm.canImport).toBe(false);
+    await vm.selectFile(Object.assign(new File([], 'labels.txt'), { text: async () => { throw new Error('Read failed'); } }));
+    expect(vm.errorMessage).toBe('Read failed');
+    expect(mocks.apply).not.toHaveBeenCalled();
+    wrapper.destroy();
+  });
+
+  it('ignores stale reads after clearing or replacing a file', async () => {
+    const { vm, wrapper } = mountDialog();
+    let finish: (value: string) => void = () => {};
+    const pending = vm.selectFile({
+      name: 'slow.txt', text: () => new Promise<string>((resolve) => { finish = resolve; }),
+    } as File);
+    expect(vm.canImport).toBe(false);
+    await vm.selectFile(file('new.txt', 'shark'));
+    finish('old');
+    await pending;
+    expect(vm.preview.names).toEqual(['shark']);
+    await vm.selectFile(null);
+    expect(vm.canImport).toBe(false);
+    wrapper.destroy();
+  });
+
+  it('blocks imports in read-only mode', async () => {
+    mocks.readOnly = true;
+    const { vm, wrapper } = mountDialog();
+    await vm.selectFile(file('labels.txt', 'shark'));
+    vm.confirmImport();
+    expect(vm.canImport).toBe(false);
+    expect(mocks.apply).not.toHaveBeenCalled();
+    wrapper.destroy();
+  });
+
+  it('keeps the dialog open when applying fails', async () => {
+    const { vm, wrapper, close } = mountDialog();
+    await vm.selectFile(file('labels.txt', 'shark'));
+    mocks.apply.mockImplementation(() => { throw new Error('Changed hierarchy'); });
+    vm.confirmImport();
+    expect(vm.errorMessage).toBe('Changed hierarchy');
+    expect(close).not.toHaveBeenCalled();
+    wrapper.destroy();
+  });
+});
diff --git a/client/dive-common/components/CategoryImportDialog.vue b/client/dive-common/components/CategoryImportDialog.vue
new file mode 100644
index 000000000..e3926c342
--- /dev/null
+++ b/client/dive-common/components/CategoryImportDialog.vue
@@ -0,0 +1,384 @@
+<script lang="ts">
+import {
+  computed, defineComponent, onBeforeUnmount, ref, watch,
+} from 'vue';
+import { useReadOnlyMode, useTrackFilters } from 'vue-media-annotator/provides';
+import { clientSettings } from 'dive-common/store/settings';
+import { CategoryImport, parseCategoryFile } from '../categoryImport';
+import WormsImport from './WormsImport.vue';
+import {
+  flattenHierarchyForest, pruneHierarchyUpward, resolveTypeHierarchy,
+} from '../typeHierarchy';
+import {
+  groupSynonymRemaps, multiAcceptedNameWarnings, synonymRemapSummary, SynonymRemap, TaxonomySources,
+} from '../worms';
+
+function mergeSynonymRemaps(
+  current: SynonymRemap[] | undefined,
+  incoming: SynonymRemap[] | undefined,
+): SynonymRemap[] | undefined {
+  if (!current?.length && !incoming?.length) return undefined;
+  const merged = new Map<string, SynonymRemap>();
+  [...(current ?? []), ...(incoming ?? [])].forEach((remap) => {
+    merged.set(`${remap.original}\0${remap.accepted}`, remap);
+  });
+  return [...merged.values()];
+}
+
+function withoutRemovedSources(
+  sources: TaxonomySources | undefined,
+  removed: ReadonlySet<string>,
+): TaxonomySources | undefined {
+  if (!sources) return undefined;
+  const next = Object.fromEntries(
+    Object.entries(sources).filter(([, record]) => !removed.has(record.scientificName)),
+  );
+  return Object.keys(next).length ? next : undefined;
+}
+
+function withoutRemovedRemaps(
+  remaps: SynonymRemap[] | undefined,
+  remaining: ReadonlySet<string>,
+): SynonymRemap[] | undefined {
+  if (!remaps?.length) return undefined;
+  const next = remaps.filter((remap) => remaining.has(remap.accepted));
+  return next.length ? next : undefined;
+}
+
+const MULTI_ACCEPTED_WARNING = 'resolves to multiple accepted names';
+
+function warningsForRemaining(
+  warnings: string[],
+  remaps: SynonymRemap[] | undefined,
+): string[] {
+  const kept = warnings.filter((warning) => !warning.includes(MULTI_ACCEPTED_WARNING));
+  return [...new Set([...kept, ...multiAcceptedNameWarnings(remaps ?? [])])];
+}
+
+function remainingStagedNames(
+  types: readonly string[],
+  hierarchy: Record<string, string> | undefined,
+): Set<string> {
+  return new Set([...types, ...Object.keys(hierarchy ?? {}), ...Object.values(hierarchy ?? {})]);
+}
+
+export default defineComponent({
+  name: 'CategoryImportDialog',
+  components: { WormsImport },
+  setup(props, { emit }) {
+    const filters = useTrackFilters();
+    const readOnlyMode = useReadOnlyMode();
+    const source = ref('file');
+    const wormsImport = ref<CategoryImport | null>(null);
+    const pastedTypes = ref('');
+    const file = ref<File | null>(null);
+    const parsedFile = ref<CategoryImport | null>(null);
+    const loading = ref(false);
+    const fileError = ref('');
+    const applyError = ref('');
+    const showSynonymDetails = ref(false);
+    watch(source, () => {
+      applyError.value = '';
+    });
+    function setWormsImport(incoming: CategoryImport | null) {
+      if (!incoming || readOnlyMode.value) return;
+      try {
+        const current = preview.value.incoming;
+        const resolved = resolveTypeHierarchy(current?.typeHierarchy ?? null, true, incoming.typeHierarchy ?? {}, 'additive');
+        const synonymRemaps = mergeSynonymRemaps(current?.synonymRemaps, incoming.synonymRemaps);
+        const staged: CategoryImport = {
+          types: [...new Set([...(current?.types ?? []), ...incoming.types])],
+          typeHierarchy: resolved.action === 'set' ? resolved.hierarchy : current?.typeHierarchy,
+          taxonomySources: { ...current?.taxonomySources, ...incoming.taxonomySources },
+          synonymRemaps,
+          warnings: [...new Set([...(current?.warnings ?? []), ...incoming.warnings])],
+        };
+        // Staging does not change the dataset. Only Add on the shared page does.
+        readVersion += 1;
+        loading.value = false;
+        file.value = null;
+        parsedFile.value = null;
+        fileError.value = '';
+        wormsImport.value = staged;
+        pastedTypes.value = staged.types.join('\n');
+        applyError.value = '';
+        showSynonymDetails.value = false;
+        source.value = 'file';
+      } catch (error) {
+        applyError.value = error instanceof Error ? error.message : 'Unable to stage WoRMS types.';
+      }
+    }
+    watch(pastedTypes, () => { applyError.value = ''; });
+    let readVersion = 0;
+    onBeforeUnmount(() => { readVersion += 1; });
+
+    async function selectFile(selected: File | null) {
+      readVersion += 1;
+      const version = readVersion;
+      wormsImport.value = null;
+      file.value = selected;
+      parsedFile.value = null;
+      fileError.value = '';
+      applyError.value = '';
+      showSynonymDetails.value = false;
+      loading.value = !!selected;
+      if (!selected) return;
+      try {
+        const contents = await selected.text();
+        if (version !== readVersion) return;
+        parsedFile.value = parseCategoryFile(contents, selected.name);
+      } catch (error) {
+        if (version === readVersion) {
+          fileError.value = error instanceof Error ? error.message : 'Unable to read category file.';
+        }
+      } finally {
+        if (version === readVersion) loading.value = false;
+      }
+    }
+
+    const preview = computed(() => {
+      let incoming: CategoryImport | null = file.value ? parsedFile.value : {
+        types: [...new Set(pastedTypes.value.split(/\r?\n/).map((name) => name.trim()).filter(Boolean))],
+        warnings: [],
+      };
+      if (!file.value && wormsImport.value) {
+        incoming = { ...wormsImport.value, types: incoming?.types ?? [] };
+      }
+      if (!incoming) {
+        return {
+          incoming: null, names: [], edges: [], tree: [], error: '',
+        };
+      }
+      const edges = Object.entries(incoming.typeHierarchy ?? {});
+      const names = [...new Set([...incoming.types, ...edges.flat()])];
+      const tree = flattenHierarchyForest(incoming.types, incoming.typeHierarchy);
+      const rankByName = new Map(
+        Object.values(incoming.taxonomySources ?? {}).map((record) => [record.scientificName, record.rank]),
+      );
+      try {
+        resolveTypeHierarchy(filters.typeHierarchy.value ?? null, true, incoming.typeHierarchy ?? {}, 'additive');
+        return {
+          incoming,
+          names,
+          edges,
+          tree: tree.map((row) => ({ ...row, rank: rankByName.get(row.name) })),
+          error: '',
+        };
+      } catch (error) {
+        return {
+          incoming,
+          names,
+          edges,
+          tree: tree.map((row) => ({ ...row, rank: rankByName.get(row.name) })),
+          error: error instanceof Error ? error.message : 'Invalid hierarchy.',
+        };
+      }
+    });
+    const synonymRemapGroups = computed(() => (
+      groupSynonymRemaps(preview.value.incoming?.synonymRemaps ?? [])
+    ));
+    const synonymRemapMessage = computed(() => (
+      synonymRemapGroups.value.length
+        ? synonymRemapSummary(preview.value.incoming?.synonymRemaps ?? [])
+        : ''
+    ));
+    const errorMessage = computed(() => (source.value === 'file' ? fileError.value : '') || preview.value.error || applyError.value);
+    const canImport = computed(() => source.value === 'file' && !readOnlyMode.value && !loading.value
+      && !errorMessage.value && preview.value.names.length > 0);
+
+    function applyStaged(next: CategoryImport) {
+      applyError.value = '';
+      if (file.value && parsedFile.value) {
+        parsedFile.value = next;
+        return;
+      }
+      if (wormsImport.value) {
+        wormsImport.value = next;
+        pastedTypes.value = next.types.join('\n');
+        return;
+      }
+      pastedTypes.value = next.types.join('\n');
+    }
+
+    function pruneStagedType(name: string) {
+      if (readOnlyMode.value || !preview.value.incoming) return;
+      const current = preview.value.incoming;
+      const { hierarchy, removed } = pruneHierarchyUpward(current.typeHierarchy, name);
+      const removedSet = new Set(removed);
+      const types = current.types.filter((type) => !removedSet.has(type));
+      if (!types.length && !hierarchy) {
+        wormsImport.value = null;
+        parsedFile.value = null;
+        file.value = null;
+        pastedTypes.value = '';
+        showSynonymDetails.value = false;
+        applyError.value = '';
+        return;
+      }
+      const remaining = remainingStagedNames(types, hierarchy);
+      const synonymRemaps = withoutRemovedRemaps(current.synonymRemaps, remaining);
+      if (!synonymRemaps?.length) showSynonymDetails.value = false;
+      applyStaged({
+        ...current,
+        types,
+        typeHierarchy: hierarchy,
+        taxonomySources: withoutRemovedSources(current.taxonomySources, removedSet),
+        synonymRemaps,
+        warnings: warningsForRemaining(current.warnings, synonymRemaps),
+      });
+    }
+
+    function confirmImport() {
+      if (!canImport.value || !preview.value.incoming) return;
+      try {
+        const { types, typeHierarchy, taxonomySources } = preview.value.incoming;
+        filters.importCategoryDefinitions(types, typeHierarchy, taxonomySources);
+        clientSettings.typeSettings.showEmptyTypes = true;
+        clientSettings.typeSettings.filterTypesByFrame = false;
+        emit('close');
+      } catch (error) {
+        applyError.value = error instanceof Error ? error.message : 'Unable to import categories.';
+      }
+    }
+    return {
+      source,
+      readOnlyMode,
+      wormsImport,
+      setWormsImport,
+      pastedTypes,
+      file,
+      loading,
+      selectFile,
+      preview,
+      synonymRemapGroups,
+      synonymRemapMessage,
+      showSynonymDetails,
+      errorMessage,
+      canImport,
+      pruneStagedType,
+      confirmImport,
+    };
+  },
+});
+</script>
+
+<template>
+  <v-card>
+    <v-card-title>
+      Import Types
+      <v-spacer />
+      <v-btn icon small aria-label="Close import" @click="$emit('close')">
+        <v-icon small>
+          mdi-close
+        </v-icon>
+      </v-btn>
+    </v-card-title>
+    <v-card-text>
+      <v-tabs v-model="source" class="mb-4">
+        <v-tab href="#file">
+          File or pasted list
+        </v-tab>
+        <v-tab href="#worms">
+          WoRMS
+        </v-tab>
+      </v-tabs>
+      <WormsImport v-if="source === 'worms'" :disabled="readOnlyMode" @prepared="setWormsImport" />
+      <template v-if="source === 'file'">
+        <p>Choose a COCO JSON or VIAME category file, or paste one type per line.</p>
+        <v-file-input
+          :value="file"
+          accept=".txt,.csv,.json"
+          label="Category file (.txt, .csv, .json)"
+          :loading="loading"
+          clearable
+          @change="selectFile"
+        />
+        <v-textarea
+          v-if="!file"
+          v-model="pastedTypes"
+          label="One type per line"
+          :readonly="!!wormsImport"
+          outlined
+          rows="6"
+        />
+        <v-btn v-if="wormsImport" small text @click="wormsImport = null; pastedTypes = ''; showSynonymDetails = false">
+          Clear staged types
+        </v-btn>
+      </template>
+      <v-alert v-if="errorMessage" type="error" dense>
+        {{ errorMessage }} No type changes were applied.
+      </v-alert>
+      <template v-if="source === 'file' && preview.incoming && preview.names.length">
+        <p>{{ preview.names.length }} types; {{ preview.edges.length }} parent relationships.</p>
+        <p v-if="preview.edges.length" class="text-caption mb-2">
+          Remove a type to drop it and unused parents above it; its children become roots.
+        </p>
+        <div class="category-preview mb-3">
+          <div
+            v-for="row in preview.tree.slice(0, 100)"
+            :key="row.name"
+            class="category-tree-row"
+            :style="{ paddingLeft: `${row.depth * 16}px` }"
+          >
+            <span>{{ row.name }}<span v-if="row.rank" class="text-caption"> · {{ row.rank }}</span></span>
+            <v-btn
+              icon
+              x-small
+              class="ml-1"
+              :aria-label="`Remove ${row.name}`"
+              :disabled="readOnlyMode"
+              @click="pruneStagedType(row.name)"
+            >
+              <v-icon x-small>
+                mdi-close
+              </v-icon>
+            </v-btn>
+          </div>
+          <div v-if="preview.tree.length > 100">
+            Showing the first 100 types.
+          </div>
+        </div>
+        <v-alert v-if="synonymRemapGroups.length" type="info" dense class="mb-2">
+          <div class="d-flex align-center flex-wrap">
+            <span>{{ synonymRemapMessage }}</span>
+            <v-btn class="ml-2" small text @click="showSynonymDetails = !showSynonymDetails">
+              {{ showSynonymDetails ? 'Hide details' : 'Show details' }}
+            </v-btn>
+          </div>
+          <div v-if="showSynonymDetails" class="category-preview mt-2">
+            <div v-for="group in synonymRemapGroups" :key="group.accepted">
+              {{ group.accepted }} ← {{ group.originals.join(', ') }}
+            </div>
+          </div>
+        </v-alert>
+        <v-alert v-for="warning in preview.incoming.warnings" :key="warning" type="warning" dense>
+          {{ warning }}
+        </v-alert>
+      </template>
+      <p>Types are added to the current dataset. Existing types and parent relationships are retained.</p>
+      <p>Imported types are shown even when they have no annotations.</p>
+    </v-card-text>
+    <v-card-actions>
+      <v-spacer />
+      <v-btn text @click="$emit('close')">
+        Cancel
+      </v-btn>
+      <v-btn v-if="source === 'file'" color="primary" :disabled="!canImport" @click="confirmImport">
+        Add
+      </v-btn>
+    </v-card-actions>
+  </v-card>
+</template>
+
+<style scoped>
+.category-preview {
+  max-height: 220px;
+  overflow-y: auto;
+  white-space: pre-wrap;
+}
+.category-tree-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+</style>
diff --git a/client/dive-common/components/Sidebar.vue b/client/dive-common/components/Sidebar.vue
index c8bc2aa2a..ba8137378 100644
--- a/client/dive-common/components/Sidebar.vue
+++ b/client/dive-common/components/Sidebar.vue
@@ -196,7 +196,6 @@ export default defineComponent({
               <TypeSettingsPanel
                 :all-types="allTypesRef"
                 :hierarchy-active="hierarchyActive"
-                @import-types="$emit('import-types', $event)"
               />
             </template>
             <template #header-trailing>
@@ -399,7 +398,6 @@ export default defineComponent({
           <TypeSettingsPanel
             :all-types="allTypesRef"
             :hierarchy-active="hierarchyActive"
-            @import-types="$emit('import-types', $event)"
           />
         </template>
         <template #header-trailing>
diff --git a/client/dive-common/components/TypeSettingsPanel.spec.ts b/client/dive-common/components/TypeSettingsPanel.spec.ts
index d64e3c2aa..1ff7363f3 100644
--- a/client/dive-common/components/TypeSettingsPanel.spec.ts
+++ b/client/dive-common/components/TypeSettingsPanel.spec.ts
@@ -1,10 +1,12 @@
 import {
-  defineComponent, h, nextTick, reactive,
+  defineComponent, h, nextTick, reactive, ref,
 } from 'vue';
 import { shallowMount } from '@vue/test-utils';
 import { clientSettings } from 'dive-common/store/settings';
 import TypeSettingsPanel from './TypeSettingsPanel.vue';
 
+vi.mock('vue-media-annotator/provides', () => ({ useReadOnlyMode: () => ref(false) }));
+
 interface PanelProps {
   allTypes: string[];
   hierarchyActive: boolean;
@@ -17,15 +19,25 @@ interface PanelProps {
  */
 function mountPanel(props: PanelProps) {
   const state = reactive(props);
+  let panel: InstanceType<typeof TypeSettingsPanel> | undefined;
   const Host = defineComponent({
-    setup: () => () => h(TypeSettingsPanel, { props: state }),
+    setup: () => () => h(TypeSettingsPanel, {
+      props: state,
+      ref: (instance) => { panel = instance as InstanceType<typeof TypeSettingsPanel>; },
+    }),
+  });
+  const wrapper = shallowMount(Host, {
+    stubs: {
+      TypeSettingsPanel: false,
+      'v-btn': { template: '<button @click="$emit(\'click\')"><slot /></button>' },
+    },
   });
-  const wrapper = shallowMount(Host, { stubs: { TypeSettingsPanel: false } });
+  if (!panel) throw new Error('Settings did not mount');
   const setProps = async (next: Partial<PanelProps>) => {
     Object.assign(state, next);
     await nextTick();
   };
-  return { wrapper, setProps };
+  return { wrapper, setProps, panel };
 }
 
 describe('TypeSettingsPanel hierarchy state', () => {
@@ -65,3 +77,14 @@ describe('TypeSettingsPanel hierarchy state', () => {
     );
   });
 });
+
+it('closes the settings popup before opening the import dialog', async () => {
+  const { wrapper, panel } = mountPanel({ allTypes: [], hierarchyActive: false });
+  panel.active = true;
+  const add = wrapper.findAll('button').wrappers.find((button) => button.text().includes('Types'));
+  if (!add) throw new Error('Import button is missing');
+  await add.trigger('click');
+  expect(panel.active).toBe(false);
+  expect(panel.importDialog).toBe(true);
+  wrapper.destroy();
+});
diff --git a/client/dive-common/components/TypeSettingsPanel.vue b/client/dive-common/components/TypeSettingsPanel.vue
index 90c16b492..637a48df3 100644
--- a/client/dive-common/components/TypeSettingsPanel.vue
+++ b/client/dive-common/components/TypeSettingsPanel.vue
@@ -6,10 +6,13 @@ import {
   ref,
   computed,
 } from 'vue';
+import { useReadOnlyMode } from 'vue-media-annotator/provides';
 import { clientSettings } from 'dive-common/store/settings';
+import CategoryImportDialog from './CategoryImportDialog.vue';
 
 export default defineComponent({
   name: 'TypeSettingsPanel',
+  components: { CategoryImportDialog },
 
   props: {
     allTypes: {
@@ -21,7 +24,8 @@ export default defineComponent({
       required: true,
     },
   },
-  setup(props, { emit }) {
+  setup(props) {
+    const readOnlyMode = useReadOnlyMode();
     const itemHeight = 45; // in pixels
     const help = reactive({
       import: 'Import multiple Types',
@@ -35,9 +39,7 @@ export default defineComponent({
       suppressionType: 'Detections lying at least the Suppression Overlap percent under an annotation of this type are hidden and excluded from counts. A detection carrying an attribute of this name set to true stays visible with its real type (optional dashed/fill styling and an eye-off tag) and is excluded from its own type\'s counts. Leave empty to disable.',
       suppressionThreshold: 'Minimum percent of a detection that must lie under suppression regions for it to be hidden (default 99).',
     });
-    const importInstructions = ref('Please provide a list of types (separated by a new line) that you would like to import');
     const importDialog = ref(false);
-    const importTypes = ref('');
     const active = ref(false);
     // Always offer the default suppression type even when no annotations use it yet.
     const suppressionTypeItems = computed(() => (
@@ -46,23 +48,13 @@ export default defineComponent({
         : ['Suppressed', ...props.allTypes]
     ));
 
-    const confirmImport = () => {
-      // Go through the importTypes and create types for importing
-      const types = importTypes.value.split('\n').filter((item) => item.length);
-      emit('import-types', types);
-      importDialog.value = false;
-      importTypes.value = '';
-    };
-
     return {
       active,
       clientSettings,
       itemHeight,
       help,
-      importInstructions,
       importDialog,
-      importTypes,
-      confirmImport,
+      readOnlyMode,
       suppressionTypeItems,
     };
   },
@@ -75,6 +67,8 @@ export default defineComponent({
       v-model="active"
       :nudge-bottom="28"
       :close-on-content-click="false"
+      min-width="380"
+      max-width="calc(100vw - 24px)"
     >
       <template #activator="{ on, attrs }">
         <v-btn
@@ -109,7 +103,8 @@ export default defineComponent({
                 small
                 outlined
                 hide-details
-                @click="importDialog = true"
+                :disabled="readOnlyMode"
+                @click="active = false; importDialog = true"
               >
                 <v-icon small>
                   mdi-plus
@@ -443,65 +438,9 @@ export default defineComponent({
 
     <v-dialog
       v-model="importDialog"
-      width="350"
+      width="550"
     >
-      <div>
-        <v-card>
-          <v-card-title>
-            Types
-            <v-spacer />
-            <v-btn
-              icon
-              small
-              @click="importDialog = false"
-            >
-              <v-icon
-                small
-              >
-                mdi-close
-              </v-icon>
-            </v-btn>
-          </v-card-title>
-          <v-card-text>
-            {{ importInstructions }}
-            <v-form>
-              <v-row class="align-center">
-                <v-col>
-                  <v-textarea
-                    v-model="importTypes"
-                    outlined
-                    no-resize
-                    rows="10"
-                  />
-                </v-col>
-              </v-row>
-            </v-form>
-            <v-alert
-              text
-              color="error"
-            >
-              Note:  You will have to check 'View Unused' in the settings to see new empty types
-            </v-alert>
-          </v-card-text>
-          <v-card-actions>
-            <v-spacer />
-            <v-btn
-              depressed=""
-              text
-              @click="importDialog = false"
-            >
-              Cancel
-            </v-btn>
-            <v-btn
-              color="primary"
-              depressed
-              @click="confirmImport"
-            >
-              Add
-            </v-btn>
-          </v-card-actions>
-        </v-card>
-      </div>
+      <CategoryImportDialog v-if="importDialog" @close="importDialog = false" />
     </v-dialog>
   </div>
 </template>
diff --git a/client/dive-common/components/Viewer.vue b/client/dive-common/components/Viewer.vue
index 6a5a3f932..ccda6f241 100644
--- a/client/dive-common/components/Viewer.vue
+++ b/client/dive-common/components/Viewer.vue
@@ -1141,6 +1141,7 @@ export default defineComponent({
         }
       }
       const typeHierarchyPatch = trackFilters.typeHierarchySavePatch();
+      const taxonomyPatch = trackFilters.taxonomySavePatch();
       try {
         const { canonicalConfigPersisted } = await saveToServer({
           customTypeStyling: trackStyleManager.getTypeStyles(
@@ -1151,15 +1152,18 @@ export default defineComponent({
           timeFilters: trackFilters.timeFilters.value,
           imageEnhancements: imageEnhancements.value,
           ...typeHierarchyPatch,
+          ...taxonomyPatch,
           // TODO Group confidence filters are not yet supported.
         }, saveSet);
         if (canonicalConfigPersisted) {
           trackFilters.markTypeHierarchyPersisted(typeHierarchyPatch);
+          trackFilters.markTaxonomyPersisted(taxonomyPatch);
         }
       } catch (err) {
         const saveResult = err as { canonicalConfigPersisted?: boolean };
         if (saveResult.canonicalConfigPersisted) {
           trackFilters.markTypeHierarchyPersisted(typeHierarchyPatch);
+          trackFilters.markTaxonomyPersisted(taxonomyPatch);
         }
         let text = 'Unable to Save Data';
         const saveErr = err as { response?: { status?: number } };
@@ -1724,6 +1728,7 @@ export default defineComponent({
         context.resetActive();
         const meta = await loadConfig(datasetId.value);
         trackFilters.setTypeHierarchy(meta.typeHierarchy);
+        trackFilters.setTaxonomySources(meta.taxonomySources);
         const hierarchyWarning = trackFilters.consumeLoadWarning();
         if (hierarchyWarning) {
           await prompt({
@@ -2906,7 +2911,6 @@ export default defineComponent({
       <sidebar
         v-if="sidebarMode === 'left'"
         :is-stereo-dataset="subType === 'stereo'"
-        @import-types="trackFilters.importTypes($event)"
         @track-seek="seekToFrame($event)"
       >
         <template>
diff --git a/client/dive-common/components/WormsImport.spec.ts b/client/dive-common/components/WormsImport.spec.ts
new file mode 100644
index 000000000..f78de2b36
--- /dev/null
+++ b/client/dive-common/components/WormsImport.spec.ts
@@ -0,0 +1,129 @@
+import { defineComponent, h, nextTick } from 'vue';
+import { shallowMount } from '@vue/test-utils';
+import { WormsRecord } from '../worms';
+import WormsImport from './WormsImport.vue';
+
+const api = vi.hoisted(() => ({ search: vi.fn(), children: vi.fn(), prepare: vi.fn() }));
+vi.mock('../worms', async (importOriginal) => ({
+  ...await importOriginal<typeof import('../worms')>(),
+  WormsClient: class {
+    search = api.search;
+
+    children = api.children;
+
+    prepare = api.prepare;
+  },
+}));
+const taxon = (id: number): WormsRecord => ({
+  AphiaID: id,
+  scientificname: `taxon ${id}`,
+  rank: 'Species',
+  status: 'accepted',
+  valid_AphiaID: id,
+  valid_name: `taxon ${id}`,
+});
+function mountImport() {
+  let vm: InstanceType<typeof WormsImport> | undefined;
+  const prepared = vi.fn();
+  const Host = defineComponent({
+    setup: () => () => h(WormsImport, {
+      on: { prepared },
+      ref: (instance) => { vm = instance as InstanceType<typeof WormsImport>; },
+    }),
+  });
+  const wrapper = shallowMount(Host, { stubs: { WormsImport: false } });
+  if (!vm) throw new Error('WoRMS import did not mount.');
+  return { vm, wrapper, prepared };
+}
+
+describe('WoRMS import selection and request lifecycle', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    api.search.mockResolvedValue([taxon(1), taxon(2)]);
+    api.children.mockResolvedValue([taxon(3)]);
+    api.prepare.mockResolvedValue({ types: ['taxon 1'], warnings: [] });
+  });
+
+  it('keeps selections across pages and navigates children back to the original search', async () => {
+    const { vm, wrapper } = mountImport();
+    vm.query = 'taxon';
+    await vm.search();
+    vm.selectPage();
+    expect(vm.selected).toHaveLength(2);
+    api.search.mockResolvedValue([taxon(4)]);
+    await vm.loadPage(51);
+    vm.selectPage();
+    expect(vm.selected.map((row) => row.AphiaID)).toEqual([1, 2, 4]);
+    expect(api.search).toHaveBeenLastCalledWith('taxon', 51, expect.any(AbortSignal));
+    await vm.browse(taxon(2));
+    expect(api.children).toHaveBeenCalledWith(2, 1, expect.any(AbortSignal));
+    await vm.back();
+    expect(vm.currentParent).toBeUndefined();
+    expect(api.search).toHaveBeenLastCalledWith('taxon', 1, expect.any(AbortSignal));
+    wrapper.destroy();
+  });
+
+  it('prepares the selected taxa and invalidates the preview when selection changes', async () => {
+    const { vm, wrapper, prepared } = mountImport();
+    vm.toggle(taxon(1));
+    await vm.prepare();
+    expect(api.prepare).toHaveBeenCalledWith([taxon(1)], true, expect.any(AbortSignal), expect.any(Function));
+    expect(prepared).toHaveBeenLastCalledWith({ types: ['taxon 1'], warnings: [] });
+    vm.toggle(taxon(2));
+    expect(prepared).toHaveBeenLastCalledWith(null);
+    vm.clearSelection();
+    expect(vm.selected).toEqual([]);
+    wrapper.destroy();
+  });
+
+  it('ignores out-of-order searches and aborts on unmount', async () => {
+    let finish: (records: WormsRecord[]) => void = () => {};
+    api.search.mockReturnValueOnce(new Promise((resolve) => { finish = resolve; }));
+    const { vm, wrapper } = mountImport();
+    vm.query = 'old';
+    const first = vm.search();
+    const firstSignal = api.search.mock.calls[0][2] as AbortSignal;
+    vm.query = 'new';
+    await vm.search();
+    expect(firstSignal.aborted).toBe(true);
+    finish([taxon(99)]);
+    await first;
+    expect(vm.results.map((row) => row.AphiaID)).toEqual([1, 2]);
+    const latestSignal = api.search.mock.calls[1][2] as AbortSignal;
+    wrapper.destroy();
+    expect(latestSignal.aborted).toBe(true);
+  });
+
+  it('does not publish a prepared import after cancellation', async () => {
+    let finish: (result: unknown) => void = () => {};
+    api.prepare.mockReturnValue(new Promise((resolve) => { finish = resolve; }));
+    const { vm, wrapper, prepared } = mountImport();
+    vm.toggle(taxon(1));
+    const pending = vm.prepare();
+    vm.cancel();
+    finish({ types: ['stale'], warnings: [] });
+    await pending;
+    expect(prepared).toHaveBeenLastCalledWith(null);
+    expect(vm.busy).toBe(false);
+    wrapper.destroy();
+  });
+
+  it('shows recoverable network errors and keeps Add disabled until preparation succeeds', async () => {
+    const { vm, wrapper, prepared } = mountImport();
+    api.search.mockRejectedValueOnce(new Error('offline'));
+    vm.query = 'taxon';
+    await vm.search();
+    expect(vm.error).toBe('offline');
+    await vm.search();
+    expect(vm.error).toBe('');
+    vm.toggle(taxon(1));
+    api.prepare.mockRejectedValueOnce(new Error('classification unavailable'));
+    await vm.prepare();
+    expect(vm.error).toBe('classification unavailable');
+    expect(prepared).toHaveBeenLastCalledWith(null);
+    await vm.prepare();
+    expect(prepared).toHaveBeenLastCalledWith({ types: ['taxon 1'], warnings: [] });
+    await nextTick();
+    wrapper.destroy();
+  });
+});
diff --git a/client/dive-common/components/WormsImport.vue b/client/dive-common/components/WormsImport.vue
new file mode 100644
index 000000000..b1255ebff
--- /dev/null
+++ b/client/dive-common/components/WormsImport.vue
@@ -0,0 +1,241 @@
+<script lang="ts">
+import {
+  computed, defineComponent, onBeforeUnmount, ref,
+} from 'vue';
+import {
+  WormsClient, WormsRecord, WORMS_PAGE_SIZE, wormsLink,
+} from '../worms';
+
+export default defineComponent({
+  name: 'WormsImport',
+  props: { disabled: { type: Boolean, default: false } },
+  setup(props, { emit }) {
+    const client = new WormsClient();
+    const query = ref('');
+    const searchedQuery = ref('');
+    const results = ref<WormsRecord[]>([]);
+    const selected = ref<WormsRecord[]>([]);
+    const parents = ref<WormsRecord[]>([]);
+    const offset = ref(1);
+    const includeParents = ref(true);
+    const busy = ref(false);
+    const preparing = ref(false);
+    const completed = ref(0);
+    const searched = ref(false);
+    const error = ref('');
+    const currentParent = computed(() => parents.value[parents.value.length - 1]);
+    const selectedIds = computed(() => new Set(selected.value.map((item) => item.AphiaID)));
+    let controller: AbortController | undefined;
+    let version = 0;
+    function cancel() {
+      version += 1;
+      controller?.abort();
+      busy.value = false;
+      preparing.value = false;
+    }
+    onBeforeUnmount(cancel);
+    function invalidate() {
+      emit('prepared', null);
+      error.value = '';
+    }
+    async function loadPage(nextOffset: number) {
+      cancel();
+      const requestVersion = version;
+      controller = new AbortController();
+      busy.value = true;
+      error.value = '';
+      results.value = [];
+      searched.value = true;
+      offset.value = nextOffset;
+      try {
+        const page = currentParent.value
+          ? await client.children(currentParent.value.AphiaID, nextOffset, controller.signal)
+          : await client.search(searchedQuery.value, nextOffset, controller.signal);
+        if (version === requestVersion) results.value = page;
+      } catch (err) {
+        if (version === requestVersion) error.value = err instanceof Error ? err.message : 'Unable to search WoRMS.';
+      } finally {
+        if (version === requestVersion) busy.value = false;
+      }
+    }
+    function search() {
+      parents.value = [];
+      searchedQuery.value = query.value;
+      return loadPage(1);
+    }
+    function browse(taxon: WormsRecord) {
+      parents.value = [...parents.value, taxon];
+      return loadPage(1);
+    }
+    function back() {
+      parents.value = parents.value.slice(0, -1);
+      return loadPage(1);
+    }
+    function toggle(taxon: WormsRecord) {
+      invalidate();
+      selected.value = selectedIds.value.has(taxon.AphiaID)
+        ? selected.value.filter((item) => item.AphiaID !== taxon.AphiaID)
+        : [...selected.value, taxon];
+    }
+    function selectPage() {
+      invalidate();
+      selected.value = [...selected.value, ...results.value.filter((item) => (
+        !selectedIds.value.has(item.AphiaID) && (item.status === 'accepted' || item.valid_AphiaID)
+      ))];
+    }
+    function clearSelection() {
+      invalidate();
+      selected.value = [];
+    }
+    async function prepare() {
+      if (props.disabled || !selected.value.length) return;
+      cancel();
+      invalidate();
+      const requestVersion = version;
+      controller = new AbortController();
+      busy.value = true;
+      preparing.value = true;
+      completed.value = 0;
+      try {
+        const incoming = await client.prepare(
+          selected.value,
+          includeParents.value,
+          controller.signal,
+          (count) => { if (version === requestVersion) completed.value = count; },
+        );
+        if (version === requestVersion) emit('prepared', incoming);
+      } catch (err) {
+        if (version === requestVersion) error.value = err instanceof Error ? err.message : 'Unable to prepare WoRMS categories.';
+      } finally {
+        if (version === requestVersion) {
+          busy.value = false;
+          preparing.value = false;
+        }
+      }
+    }
+    return {
+      query,
+      results,
+      selected,
+      selectedIds,
+      includeParents,
+      busy,
+      preparing,
+      completed,
+      searched,
+      error,
+      currentParent,
+      offset,
+      pageSize: WORMS_PAGE_SIZE,
+      search,
+      browse,
+      back,
+      loadPage,
+      toggle,
+      selectPage,
+      clearSelection,
+      prepare,
+      invalidate,
+      cancel,
+      wormsLink,
+    };
+  },
+});
+</script>
+
+<template>
+  <div>
+    <p>Search marine scientific names in the World Register of Marine Species (WoRMS).</p>
+    <v-text-field
+      v-model="query"
+      label="Scientific name (species, genus, or family)"
+      :disabled="busy"
+      @keydown.enter.prevent="search"
+    />
+    <v-btn small :disabled="busy || query.trim().length < 2" @click="search">
+      Search
+    </v-btn>
+    <div v-if="currentParent" class="mt-3">
+      <v-btn small text :disabled="busy" @click="back">
+        Back
+      </v-btn>
+      Children of {{ currentParent.scientificname }}
+    </div>
+    <v-alert v-if="error" type="error" dense class="mt-3">
+      {{ error }}
+      <v-btn v-if="!busy" small text @click="loadPage(offset)">
+        Retry search
+      </v-btn>
+    </v-alert>
+    <v-progress-linear v-if="busy" indeterminate class="mt-3" />
+    <div v-if="preparing" class="mt-2">
+      Preparing {{ completed }} / {{ selected.length }} selected taxa…
+    </div>
+    <v-btn v-if="busy" small text @click="cancel">
+      Cancel request
+    </v-btn>
+    <div v-if="searched && !busy && !error && !results.length" class="mt-3">
+      No matching taxa on this page.
+    </div>
+    <div v-if="results.length" class="worms-results mt-3">
+      <div v-for="taxon in results" :key="taxon.AphiaID" class="worms-row">
+        <v-checkbox
+          :input-value="selectedIds.has(taxon.AphiaID)"
+          :disabled="busy || (taxon.status !== 'accepted' && !taxon.valid_AphiaID)"
+          :label="taxon.scientificname"
+          dense
+          hide-details
+          class="mt-0"
+          @change="toggle(taxon)"
+        />
+        <div class="ml-8 text-caption">
+          {{ taxon.rank }} · {{ taxon.authority }} · {{ taxon.status }}
+          <span v-if="taxon.valid_name && taxon.valid_name !== taxon.scientificname">
+            → {{ taxon.valid_name }}
+          </span>
+          <a :href="wormsLink(taxon.AphiaID)" target="_blank" rel="noopener noreferrer">WoRMS {{ taxon.AphiaID }}</a>
+          <v-btn small text :disabled="busy" @click="browse(taxon)">
+            Browse children
+          </v-btn>
+        </div>
+      </div>
+    </div>
+    <div v-if="searched" class="my-3">
+      <v-btn small :disabled="busy || offset === 1" @click="loadPage(offset - pageSize)">
+        Previous
+      </v-btn>
+      <span class="mx-2">Page {{ Math.ceil(offset / pageSize) }}</span>
+      <v-btn small :disabled="busy || results.length < pageSize" @click="loadPage(offset + pageSize)">
+        Next
+      </v-btn>
+      <v-btn small text :disabled="busy || !results.length" @click="selectPage">
+        Select page
+      </v-btn>
+    </div>
+    <p class="mt-3">
+      {{ selected.length }} taxa selected across pages.
+      <v-btn small text :disabled="busy || !selected.length" @click="clearSelection">
+        Clear selection
+      </v-btn>
+    </p>
+    <div v-if="selected.length" class="worms-selection">
+      <v-chip v-for="taxon in selected.slice(0, 100)" :key="taxon.AphiaID" small close :disabled="busy" @click:close="toggle(taxon)">
+        {{ taxon.scientificname }}
+      </v-chip>
+      <span v-if="selected.length > 100">Showing the first 100 selected taxa.</span>
+    </div>
+    <v-checkbox v-model="includeParents" :disabled="busy" label="Include taxonomic parent categories" @change="invalidate" />
+    <v-btn small color="primary" :disabled="disabled || busy || !selected.length" @click="prepare">
+      Add
+    </v-btn>
+    <p class="mt-3 text-caption">
+      Names and classifications supplied by <a href="https://www.marinespecies.org" target="_blank" rel="noopener noreferrer">WoRMS</a>. Internet access is required. Synonyms are imported using their accepted scientific names.
+    </p>
+  </div>
+</template>
+
+<style scoped>
+.worms-results { max-height: 280px; overflow-y: auto; }
+.worms-selection { max-height: 100px; overflow-y: auto; }
+.worms-row { padding: 8px 0; border-bottom: 1px solid #8884; }
+</style>
diff --git a/client/dive-common/typeHierarchy.spec.ts b/client/dive-common/typeHierarchy.spec.ts
index 602ed7e08..d8091a892 100644
--- a/client/dive-common/typeHierarchy.spec.ts
+++ b/client/dive-common/typeHierarchy.spec.ts
@@ -3,8 +3,10 @@ import {
   acceptPairAsCorrect,
   compareTypeNames,
   compileHierarchy,
+  flattenHierarchyForest,
   mergePairs,
   normalizeTypeHierarchy,
+  pruneHierarchyUpward,
   reassignPairs,
   removeHierarchyType,
   removePair,
@@ -292,6 +294,66 @@ describe('hierarchy editing transformations', () => {
     });
   });
 
+  describe('pruneHierarchyUpward', () => {
+    it('makes children roots and drops unused ancestors', () => {
+      expect(pruneHierarchyUpward({
+        something: 'Animalia',
+        Animalia: 'Biota',
+      }, 'Animalia')).toEqual({
+        hierarchy: undefined,
+        removed: ['Animalia', 'Biota'],
+      });
+    });
+
+    it('keeps shared ancestors still used by another branch', () => {
+      expect(pruneHierarchyUpward({
+        fish: 'Animalia',
+        Animalia: 'Biota',
+        oak: 'Plantae',
+        Plantae: 'Biota',
+      }, 'Animalia')).toEqual({
+        hierarchy: { oak: 'Plantae', Plantae: 'Biota' },
+        removed: ['Animalia'],
+      });
+    });
+
+    it('preserves deeper structure under promoted children', () => {
+      expect(pruneHierarchyUpward({
+        shark: 'Chordata',
+        Chordata: 'Animalia',
+        Animalia: 'Biota',
+      }, 'Animalia')).toEqual({
+        hierarchy: { shark: 'Chordata' },
+        removed: ['Animalia', 'Biota'],
+      });
+    });
+
+    it('removes a leaf and unused ancestors above it', () => {
+      expect(pruneHierarchyUpward({
+        shark: 'fish',
+        fish: 'animal',
+      }, 'shark')).toEqual({
+        hierarchy: undefined,
+        removed: ['shark', 'fish', 'animal'],
+      });
+    });
+  });
+
+  describe('flattenHierarchyForest', () => {
+    it('orders roots and children by type name with depth', () => {
+      expect(flattenHierarchyForest(
+        ['shark', 'tern'],
+        { shark: 'fish', fish: 'animal', tern: 'bird' },
+      )).toEqual([
+        { name: 'animal', depth: 0 },
+        { name: 'fish', depth: 1 },
+        { name: 'shark', depth: 2 },
+        { name: 'bird', depth: 0 },
+        { name: 'tern', depth: 1 },
+      ]);
+    });
+  });
+
   describe('updateHierarchyTypeDefinition', () => {
     it('sets, reparents, and clears edges without mutating unrelated branches', () => {
       expect(updateHierarchyTypeDefinition(undefined, 'cod', 'cod', 'fish'))
diff --git a/client/dive-common/typeHierarchy.ts b/client/dive-common/typeHierarchy.ts
index ae772c25d..543136a31 100644
--- a/client/dive-common/typeHierarchy.ts
+++ b/client/dive-common/typeHierarchy.ts
@@ -335,6 +335,81 @@ export function removeHierarchyType(
   return normalizeTypeHierarchy(Object.fromEntries(updated));
 }
 
+export interface PruneHierarchyResult {
+  hierarchy: TypeHierarchy | undefined;
+  removed: readonly string[];
+}
+
+/**
+ * Remove `type` so its children become roots (not reparented to the grandparent),
+ * then walk ancestors upward and drop any that no longer have children.
+ */
+export function pruneHierarchyUpward(
+  hierarchy: TypeHierarchy | undefined,
+  type: string,
+): PruneHierarchyResult {
+  const normalized = normalizeTypeHierarchy(hierarchy || {}) || {};
+  const updated = new Map<string, string>();
+  Object.keys(normalized).forEach((child) => {
+    if (child === type) return;
+    const parent = normalized[child];
+    if (parent === type) return;
+    updated.set(child, parent);
+  });
+
+  const removed = new Set<string>([type]);
+  let ancestor: string | undefined = hasOwn(normalized, type) ? normalized[type] : undefined;
+  while (ancestor !== undefined) {
+    const hasChild = [...updated.values()].includes(ancestor);
+    if (hasChild) break;
+    const parentOfAncestor = updated.get(ancestor) ?? (
+      hasOwn(normalized, ancestor) ? normalized[ancestor] : undefined
+    );
+    updated.delete(ancestor);
+    removed.add(ancestor);
+    ancestor = parentOfAncestor;
+  }
+
+  return {
+    hierarchy: normalizeTypeHierarchy(Object.fromEntries(updated)),
+    removed: [...removed],
+  };
+}
+
+export interface HierarchyForestRow {
+  name: string;
+  depth: number;
+}
+
+/** Depth-first forest of hierarchy members plus any extra names (roots first). */
+export function flattenHierarchyForest(
+  names: readonly string[],
+  hierarchy: TypeHierarchy | undefined,
+): HierarchyForestRow[] {
+  const normalized = normalizeTypeHierarchy(hierarchy || {}) || {};
+  const children = new Map<string, string[]>();
+  const members = new Set<string>(names);
+  Object.entries(normalized).forEach(([child, parent]) => {
+    members.add(child);
+    members.add(parent);
+    const siblings = children.get(parent);
+    if (siblings) siblings.push(child);
+    else children.set(parent, [child]);
+  });
+  children.forEach((siblings, parent) => {
+    children.set(parent, sortedNames(siblings));
+  });
+
+  const roots = sortedNames([...members].filter((name) => !hasOwn(normalized, name)));
+  const rows: HierarchyForestRow[] = [];
+  const visit = (name: string, depth: number) => {
+    rows.push({ name, depth });
+    (children.get(name) || []).forEach((child) => visit(child, depth + 1));
+  };
+  roots.forEach((root) => visit(root, 0));
+  return rows;
+}
+
 /** Build the final hierarchy for an atomic type rename and parent edit. */
 export function updateHierarchyTypeDefinition(
   hierarchy: TypeHierarchy | undefined,
diff --git a/client/dive-common/use/useSave.ts b/client/dive-common/use/useSave.ts
index e76f30f99..fff3529be 100644
--- a/client/dive-common/use/useSave.ts
+++ b/client/dive-common/use/useSave.ts
@@ -98,7 +98,7 @@ export default function useSave(
         const cameraMeta = saveId === datasetId.value
           ? datasetMeta
           : Object.fromEntries(
-            Object.entries(datasetMeta).filter(([key]) => key !== 'typeHierarchy'),
+            Object.entries(datasetMeta).filter(([key]) => key !== 'typeHierarchy' && key !== 'taxonomySources'),
           );
         if (saveId === datasetId.value) {
           canonicalConfigScheduled = true;
diff --git a/client/dive-common/worms.spec.ts b/client/dive-common/worms.spec.ts
new file mode 100644
index 000000000..1715ee7b8
--- /dev/null
+++ b/client/dive-common/worms.spec.ts
@@ -0,0 +1,187 @@
+import {
+  groupSynonymRemaps, multiAcceptedNameWarnings, synonymRemapSummary, WormsClient, WormsRecord,
+} from './worms';
+
+const taxon = (id: number, name: string, extra = {}): WormsRecord => ({
+  AphiaID: id,
+  scientificname: name,
+  rank: 'Species',
+  status: 'accepted',
+  valid_AphiaID: id,
+  valid_name: name,
+  ...extra,
+});
+const response = (value: unknown, status = 200) => ({
+  ok: status < 400, status, json: async () => value,
+} as Response);
+const signal = () => new AbortController().signal;
+
+describe('synonym remap presentation', () => {
+  it('groups remaps by accepted name and summarizes counts', () => {
+    const remaps = [
+      { original: 'old salmon', accepted: 'salmon' },
+      { original: 'Salmo old', accepted: 'salmon' },
+      { original: 'old trout', accepted: 'trout' },
+    ];
+    expect(groupSynonymRemaps(remaps)).toEqual([
+      { accepted: 'salmon', originals: ['old salmon', 'Salmo old'] },
+      { accepted: 'trout', originals: ['old trout'] },
+    ]);
+    expect(synonymRemapSummary(remaps)).toBe('3 synonyms will be imported as 2 accepted names.');
+    expect(synonymRemapSummary([{ original: 'old', accepted: 'new' }]))
+      .toBe('1 synonym will be imported as 1 accepted name.');
+  });
+
+  it('warns only when one original still maps to multiple accepted names', () => {
+    expect(multiAcceptedNameWarnings([
+      { original: 'Seriola gigas', accepted: 'Seriola dumerili' },
+      { original: 'Seriola gigas', accepted: 'Seriola hippos' },
+      { original: 'old trout', accepted: 'trout' },
+    ])).toEqual([
+      '"Seriola gigas" resolves to multiple accepted names: "Seriola dumerili", "Seriola hippos".',
+    ]);
+    expect(multiAcceptedNameWarnings([
+      { original: 'Seriola gigas', accepted: 'Seriola hippos' },
+    ])).toEqual([]);
+  });
+});
+
+describe('WoRMS client', () => {
+  it('does not bind native browser fetch to the client instance', async () => {
+    const browserFetch = vi.fn(function browserFetch(this: unknown) {
+      if (this !== undefined && this !== globalThis) throw new TypeError('Illegal invocation');
+      return Promise.resolve(response([taxon(1, 'fish')]));
+    });
+    vi.stubGlobal('fetch', browserFetch);
+    try {
+      expect(await new WormsClient().search('fish', 1, signal())).toHaveLength(1);
+      expect(browserFetch).toHaveBeenCalledTimes(1);
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+
+  it('uses encoded, paginated marine searches with no credentials and handles empty pages', async () => {
+    const fetcher = vi.fn().mockResolvedValueOnce(response([taxon(1, 'fish')]))
+      .mockResolvedValueOnce(response(null, 204));
+    const client = new WormsClient(fetcher);
+    expect(await client.search(' a/b ', 51, signal())).toHaveLength(1);
+    expect(fetcher).toHaveBeenCalledWith(
+      'https://www.marinespecies.org/rest/AphiaRecordsByName/a%2Fb?like=true&marine_only=true&offset=51',
+      expect.objectContaining({ credentials: 'omit' }),
+    );
+    expect(await client.children(1, 1, signal())).toEqual([]);
+    expect(fetcher.mock.calls[1][0]).toContain('AphiaChildrenByAphiaID/1?');
+  });
+
+  it('resolves synonyms, deduplicates accepted taxa, and imports complete parent chains', async () => {
+    const fetcher = vi.fn().mockImplementation(async (url: string) => {
+      if (url.includes('AphiaRecordByAphiaID')) return response(taxon(3, 'salmon'));
+      return response({
+        AphiaID: 1,
+        scientificname: 'animal',
+        rank: 'Kingdom',
+        child: {
+          AphiaID: 2,
+          scientificname: 'fish',
+          rank: 'Class',
+          child: {
+            AphiaID: 3, scientificname: 'salmon', rank: 'Species', child: null,
+          },
+        },
+      });
+    });
+    const client = new WormsClient(fetcher);
+    const progress = vi.fn();
+    const imported = await client.prepare([
+      taxon(4, 'old salmon', { status: 'unaccepted', valid_AphiaID: 3 }), taxon(3, 'salmon'),
+    ], true, signal(), progress);
+    expect(imported.types).toEqual(['salmon']);
+    expect(imported.typeHierarchy).toEqual({ fish: 'animal', salmon: 'fish' });
+    expect(imported.taxonomySources?.['3']).toEqual({ aphiaId: 3, scientificName: 'salmon', rank: 'Species' });
+    expect(Object.keys(imported.taxonomySources!)).toEqual(['1', '2', '3']);
+    expect(imported.synonymRemaps).toEqual([{ original: 'old salmon', accepted: 'salmon' }]);
+    expect(imported.warnings).toEqual([]);
+    expect(fetcher).toHaveBeenCalledTimes(2);
+    expect(progress).toHaveBeenLastCalledWith(2);
+    await client.prepare([taxon(3, 'salmon')], true, signal());
+    expect(fetcher).toHaveBeenCalledTimes(2);
+  });
+
+  it('warns when one synonym name resolves to multiple accepted taxa', async () => {
+    const fetcher = vi.fn().mockImplementation(async (url: string) => {
+      if (url.endsWith('/10')) return response(taxon(10, 'Seriola dumerili'));
+      if (url.endsWith('/20')) return response(taxon(20, 'Seriola hippos'));
+      throw new Error(`unexpected ${url}`);
+    });
+    const imported = await new WormsClient(fetcher).prepare([
+      taxon(1, 'Seriola gigas', { status: 'unaccepted', valid_AphiaID: 10 }),
+      taxon(2, 'Seriola gigas', { status: 'unaccepted', valid_AphiaID: 20 }),
+    ], false, signal());
+    expect(imported.types).toEqual(['Seriola dumerili', 'Seriola hippos']);
+    expect(imported.synonymRemaps).toEqual([
+      { original: 'Seriola gigas', accepted: 'Seriola dumerili' },
+      { original: 'Seriola gigas', accepted: 'Seriola hippos' },
+    ]);
+    expect(imported.warnings).toEqual([
+      '"Seriola gigas" resolves to multiple accepted names: "Seriola dumerili", "Seriola hippos".',
+    ]);
+  });
+
+  it('can import selected names without parent lookups', async () => {
+    const fetcher = vi.fn();
+    const imported = await new WormsClient(fetcher).prepare([taxon(1, 'fish')], false, signal());
+    expect(imported.types).toEqual(['fish']);
+    expect(imported.typeHierarchy).toBeUndefined();
+    expect(imported.taxonomySources?.['1'].aphiaId).toBe(1);
+    expect(imported.synonymRemaps).toBeUndefined();
+    expect(fetcher).not.toHaveBeenCalled();
+  });
+
+  it('rejects taxa without accepted names and ambiguous names', async () => {
+    const client = new WormsClient(vi.fn());
+    await expect(client.prepare([taxon(1, 'unknown', { status: 'unaccepted', valid_AphiaID: null })], false, signal()))
+      .rejects.toThrow('no accepted');
+    await expect(client.prepare([taxon(1, 'fish'), taxon(2, 'fish')], false, signal()))
+      .rejects.toThrow('share the name');
+  });
+
+  it.each([null, {}, {
+    AphiaID: 99, scientificname: 'other', rank: 'Species', child: null,
+  }])('rejects malformed or incomplete classifications', async (classification) => {
+    const client = new WormsClient(vi.fn().mockResolvedValue(response(classification)));
+    await expect(client.prepare([taxon(1, 'fish')], true, signal())).rejects.toThrow();
+  });
+
+  it.each([429, 500])('reports HTTP %s without caching failures', async (status) => {
+    const fetcher = vi.fn().mockResolvedValueOnce(response(null, status)).mockResolvedValueOnce(response([]));
+    const client = new WormsClient(fetcher);
+    await expect(client.search('fish', 1, signal())).rejects.toThrow();
+    expect(await client.search('fish', 1, signal())).toEqual([]);
+    expect(fetcher).toHaveBeenCalledTimes(2);
+  });
+
+  it('reports network failures', async () => {
+    const client = new WormsClient(vi.fn().mockRejectedValue(new TypeError('fetch failed')));
+    await expect(client.search('fish', 1, signal())).rejects.toThrow('internet connection');
+  });
+
+  it('cancels requests and times out stalled requests', async () => {
+    vi.useFakeTimers();
+    try {
+      const fetcher = vi.fn((_url, options) => new Promise<Response>((resolve, reject) => {
+        options.signal.addEventListener('abort', () => reject(new Error('aborted')));
+      }));
+      const client = new WormsClient(fetcher);
+      const controller = new AbortController();
+      const cancelled = expect(client.search('fish', 1, controller.signal)).rejects.toThrow('cancelled');
+      controller.abort();
+      await cancelled;
+      const timeout = expect(client.search('fish', 1, signal())).rejects.toThrow('timed out');
+      await vi.advanceTimersByTimeAsync(20000);
+      await timeout;
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});
diff --git a/client/dive-common/worms.ts b/client/dive-common/worms.ts
new file mode 100644
index 000000000..c101a7f08
--- /dev/null
+++ b/client/dive-common/worms.ts
@@ -0,0 +1,229 @@
+import type { CategoryImport } from './categoryImport';
+import { normalizeTypeHierarchy } from './typeHierarchy';
+
+export interface TaxonomySource {
+  aphiaId: number;
+  scientificName: string;
+  rank: string;
+}
+/** Source records keyed by AphiaID; retained as import provenance even if a type is later renamed. */
+export type TaxonomySources = Record<string, TaxonomySource>;
+
+export interface WormsRecord {
+  AphiaID: number;
+  scientificname: string;
+  rank: string;
+  status: string;
+  authority?: string;
+  valid_AphiaID: number | null;
+  valid_name: string | null;
+}
+
+/** A WoRMS synonym (or unaccepted name) resolved to its accepted scientific name. */
+export interface SynonymRemap {
+  original: string;
+  accepted: string;
+}
+
+export interface SynonymRemapGroup {
+  accepted: string;
+  originals: string[];
+}
+
+/** Group remaps by accepted name for a compact import preview. */
+export function groupSynonymRemaps(remaps: SynonymRemap[]): SynonymRemapGroup[] {
+  const groups = new Map<string, string[]>();
+  remaps.forEach(({ original, accepted }) => {
+    const list = groups.get(accepted) ?? [];
+    if (!list.includes(original)) list.push(original);
+    groups.set(accepted, list);
+  });
+  return [...groups.entries()]
+    .sort(([a], [b]) => a.localeCompare(b, undefined, { sensitivity: 'base' }))
+    .map(([accepted, originals]) => ({
+      accepted,
+      originals: [...originals].sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' })),
+    }));
+}
+
+export function synonymRemapSummary(remaps: SynonymRemap[]): string {
+  const groups = groupSynonymRemaps(remaps);
+  const synonymCount = groups.reduce((n, group) => n + group.originals.length, 0);
+  const acceptedCount = groups.length;
+  const synonymLabel = synonymCount === 1 ? 'synonym' : 'synonyms';
+  const acceptedLabel = acceptedCount === 1 ? 'accepted name' : 'accepted names';
+  return `${synonymCount} ${synonymLabel} will be imported as ${acceptedCount} ${acceptedLabel}.`;
+}
+
+/** Warn when one original synonym name still maps to more than one accepted taxon. */
+export function multiAcceptedNameWarnings(remaps: SynonymRemap[]): string[] {
+  const byOriginal = new Map<string, Set<string>>();
+  remaps.forEach(({ original, accepted }) => {
+    const targets = byOriginal.get(original) ?? new Set();
+    targets.add(accepted);
+    byOriginal.set(original, targets);
+  });
+  const warnings: string[] = [];
+  byOriginal.forEach((targets, originalName) => {
+    if (targets.size > 1) {
+      const listed = [...targets].sort((a, b) => a.localeCompare(b)).map((name) => `"${name}"`).join(', ');
+      warnings.push(`"${originalName}" resolves to multiple accepted names: ${listed}.`);
+    }
+  });
+  return warnings;
+}
+
+interface Classification {
+  AphiaID: number;
+  scientificname: string;
+  rank: string;
+  child: Classification | null;
+}
+
+export const WORMS_PAGE_SIZE = 50;
+export const wormsLink = (id: number) => `https://www.marinespecies.org/aphia.php?p=taxdetails&id=${id}`;
+
+function validTaxon(value: unknown): value is Classification {
+  const taxon = value as Classification | null;
+  return !!taxon && Number.isSafeInteger(taxon.AphiaID) && taxon.AphiaID > 0
+    && typeof taxon.scientificname === 'string' && !!taxon.scientificname.trim()
+    && typeof taxon.rank === 'string';
+}
+
+function record(value: unknown): WormsRecord {
+  if (!validTaxon(value) || typeof (value as unknown as WormsRecord).status !== 'string') {
+    throw new Error('WoRMS returned an invalid taxon record.');
+  }
+  return value as unknown as WormsRecord;
+}
+
+/** One client per open dialog. Requests are cancellable and successful lookups are bounded/cached. */
+export class WormsClient {
+  private cache = new Map<string, unknown>();
+
+  constructor(private request: typeof fetch = (...args) => fetch(...args)) {
+    // Native browser fetch requires Window (or undefined) as its receiver.
+    // Calling a stored reference as this.request binds it to WormsClient instead.
+    // The wrapper preserves the browser receiver while allowing test transports.
+  }
+
+  private async get(path: string, signal: AbortSignal): Promise<unknown> {
+    if (signal.aborted) throw new Error('WoRMS request cancelled.');
+    if (this.cache.has(path)) return this.cache.get(path);
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signal.addEventListener('abort', abort, { once: true });
+    const timeout = setTimeout(abort, 20000);
+    try {
+      const response = await this.request(`https://www.marinespecies.org/rest/${path}`, {
+        signal: controller.signal, credentials: 'omit', headers: { Accept: 'application/json' },
+      });
+      if (!response.ok) {
+        throw new Error(response.status === 429
+          ? 'WoRMS is receiving too many requests. Wait a moment and try again.'
+          : `WoRMS request failed (${response.status}). Please try again.`);
+      }
+      const value: unknown = response.status === 204 ? null : await response.json();
+      if (this.cache.size >= 200) this.cache.delete(this.cache.keys().next().value!);
+      this.cache.set(path, value);
+      return value;
+    } catch (error) {
+      if (signal.aborted) throw new Error('WoRMS request cancelled.');
+      if (controller.signal.aborted) throw new Error('WoRMS request timed out. Please try again.');
+      if (error instanceof TypeError) throw new Error('Cannot reach WoRMS. Check your internet connection and try again.');
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+      signal.removeEventListener('abort', abort);
+    }
+  }
+
+  async search(name: string, offset: number, signal: AbortSignal): Promise<WormsRecord[]> {
+    if (name.trim().length < 2) throw new Error('Enter at least two characters.');
+    return this.page(`AphiaRecordsByName/${encodeURIComponent(name.trim())}?like=true&marine_only=true&offset=${offset}`, signal);
+  }
+
+  async children(id: number, offset: number, signal: AbortSignal): Promise<WormsRecord[]> {
+    return this.page(`AphiaChildrenByAphiaID/${id}?marine_only=true&offset=${offset}`, signal);
+  }
+
+  private async page(path: string, signal: AbortSignal): Promise<WormsRecord[]> {
+    const result = await this.get(path, signal);
+    if (result === null) return [];
+    if (!Array.isArray(result)) throw new Error('WoRMS returned an invalid result list.');
+    return result.map(record);
+  }
+
+  async prepare(
+    selected: WormsRecord[],
+    includeParents: boolean,
+    signal: AbortSignal,
+    progress: (completed: number) => void = () => {},
+  ): Promise<CategoryImport> {
+    const types = new Set<string>();
+    const sources: TaxonomySources = {};
+    const names = new Map<string, number>();
+    const edges = new Map<string, string>();
+    const remaps = new Map<string, SynonymRemap>();
+    const addTaxon = (taxon: Classification | WormsRecord) => {
+      const existing = names.get(taxon.scientificname);
+      if (existing !== undefined && existing !== taxon.AphiaID) {
+        throw new Error(`Different WoRMS taxa share the name "${taxon.scientificname}". Import them separately with distinct type names.`);
+      }
+      names.set(taxon.scientificname, taxon.AphiaID);
+      sources[String(taxon.AphiaID)] = {
+        aphiaId: taxon.AphiaID, scientificName: taxon.scientificname, rank: taxon.rank,
+      };
+    };
+    // Sequential requests avoid a burst against the public service; cached ancestors/records are reused.
+    for (let i = 0; i < selected.length; i += 1) {
+      const original = selected[i];
+      let accepted = original;
+      if (original.status !== 'accepted') {
+        if (!Number.isSafeInteger(original.valid_AphiaID) || !original.valid_AphiaID) {
+          throw new Error(`"${original.scientificname}" has no accepted WoRMS name. Choose another taxon.`);
+        }
+        // eslint-disable-next-line no-await-in-loop
+        accepted = record(await this.get(`AphiaRecordByAphiaID/${original.valid_AphiaID}`, signal));
+        if (accepted.status !== 'accepted') throw new Error(`WoRMS could not resolve "${original.scientificname}" to an accepted name.`);
+        remaps.set(`${original.scientificname}\0${accepted.scientificname}`, {
+          original: original.scientificname,
+          accepted: accepted.scientificname,
+        });
+      }
+      addTaxon(accepted);
+      if (!types.has(accepted.scientificname) && includeParents) {
+        // eslint-disable-next-line no-await-in-loop
+        let node = await this.get(`AphiaClassificationByAphiaID/${accepted.AphiaID}`, signal);
+        let parent: string | undefined;
+        const visited = new Set<number>();
+        let lastId: number | undefined;
+        while (node !== null && node !== undefined) {
+          if (!validTaxon(node) || visited.has(node.AphiaID)) throw new Error('WoRMS returned an invalid classification.');
+          visited.add(node.AphiaID);
+          addTaxon(node);
+          if (parent !== undefined) {
+            if (edges.has(node.scientificname) && edges.get(node.scientificname) !== parent) {
+              throw new Error(`WoRMS returned conflicting parents for "${node.scientificname}".`);
+            }
+            edges.set(node.scientificname, parent);
+          }
+          parent = node.scientificname;
+          lastId = node.AphiaID;
+          node = node.child;
+        }
+        if (lastId !== accepted.AphiaID) throw new Error(`WoRMS returned an incomplete classification for "${accepted.scientificname}".`);
+      }
+      types.add(accepted.scientificname);
+      progress(i + 1);
+    }
+    const synonymRemaps = [...remaps.values()];
+    return {
+      types: [...types],
+      typeHierarchy: normalizeTypeHierarchy(Object.fromEntries(edges)),
+      taxonomySources: sources,
+      synonymRemaps: synonymRemaps.length ? synonymRemaps : undefined,
+      warnings: multiAcceptedNameWarnings(synonymRemaps),
+    };
+  }
+}
diff --git a/client/platform/desktop/backend/native/common.spec.ts b/client/platform/desktop/backend/native/common.spec.ts
index 47cc94305..bfa31f20f 100644
--- a/client/platform/desktop/backend/native/common.spec.ts
+++ b/client/platform/desktop/backend/native/common.spec.ts
@@ -1354,6 +1354,14 @@ describe('native.common', () => {
     expect(data.imageData[1].timestamp).toBeUndefined();
   });
 
+  it('persists WoRMS provenance across desktop save and reload', async () => {
+    const taxonomySources = { 126175: { aphiaId: 126175, scientificName: 'Sebastes', rank: 'Genus' } };
+    await common.saveConfig(settings, 'projectid1', { taxonomySources });
+    expect((await common.loadConfig(settings, 'projectid1', urlMapper)).taxonomySources).toEqual(taxonomySources);
+    await common.saveConfig(settings, 'projectid1', { confidenceFilters: { default: 0.5 } });
+    expect((await common.loadConfig(settings, 'projectid1', urlMapper)).taxonomySources).toEqual(taxonomySources);
+  });
+
   it('saveConfig sets, clears, and atomically rejects a type hierarchy', async () => {
     const legacyProject = common.getProjectDir(settings, 'projectid1');
     await common.saveProjectConfig(
diff --git a/client/platform/desktop/backend/native/common.ts b/client/platform/desktop/backend/native/common.ts
index d33d9737e..7c9982dd5 100644
--- a/client/platform/desktop/backend/native/common.ts
+++ b/client/platform/desktop/backend/native/common.ts
@@ -1395,6 +1395,9 @@ async function saveConfig(settings: Settings, datasetId: string, args: DatasetCo
     if (args.error) {
       existing.error = args.error;
     }
+    if (args.taxonomySources) {
+      existing.taxonomySources = args.taxonomySources;
+    }
     if (args.datasetInfo) {
       existing.datasetInfo = args.datasetInfo;
     }
diff --git a/client/src/TrackFilterControls.spec.ts b/client/src/TrackFilterControls.spec.ts
index b94043c80..87260cb00 100644
--- a/client/src/TrackFilterControls.spec.ts
+++ b/client/src/TrackFilterControls.spec.ts
@@ -1368,3 +1368,78 @@ describe('useAnnotationFilters', () => {
     expect(filters.typeHierarchySavePatch()).toEqual({ typeHierarchy: null });
   });
 });
+
+describe('category definition imports', () => {
+  it('merges types and hierarchy and marks metadata for persistence', () => {
+    const pending = vi.fn();
+    const filters = makeTrackFilterControls(pending);
+    filters.importTypes(['existing'], false);
+    filters.setTypeHierarchy({ fish: 'animal' });
+    filters.importCategoryDefinitions(['shark'], { shark: 'fish' });
+    expect(filters.configuredTypes.value).toEqual(['existing', 'shark']);
+    expect(filters.allTypes.value).toEqual(expect.arrayContaining(['animal', 'fish', 'shark']));
+    expect(filters.typeHierarchySavePatch()).toEqual({ typeHierarchy: { fish: 'animal', shark: 'fish' } });
+    expect(pending).toHaveBeenCalledWith({ action: 'meta' });
+    filters.importCategoryDefinitions(['other']);
+    expect(filters.typeHierarchySavePatch()).toEqual({ typeHierarchy: { fish: 'animal', shark: 'fish' } });
+  });
+
+  it.each<Record<string, string>>([{ fish: 'other' }, { animal: 'fish' }])('rejects conflicts atomically: %j', (hierarchy) => {
+    const pending = vi.fn();
+    const filters = makeTrackFilterControls(pending);
+    filters.setTypeHierarchy({ fish: 'animal' });
+    expect(() => filters.importCategoryDefinitions(['new'], hierarchy)).toThrow(TypeHierarchyError);
+    expect(filters.configuredTypes.value).not.toContain('new');
+    expect(filters.typeHierarchy.value).toEqual({ fish: 'animal' });
+    expect(filters.typeHierarchySavePatch()).toEqual({});
+    expect(pending).not.toHaveBeenCalled();
+  });
+
+  it('does not modify annotations when adding hierarchy relationships', () => {
+    const { filters, cameraStore } = makePairFixture([[['fish', 0.8], ['animal', 0.3]]]);
+    const before = cameraStore.sortedTracks.value.map((track) => track.confidencePairs);
+    filters.importCategoryDefinitions(['fish'], { fish: 'animal' });
+    expect(cameraStore.sortedTracks.value.map((track) => track.confidencePairs)).toEqual(before);
+  });
+});
+
+describe('WoRMS import provenance', () => {
+  const sources = { 3: { aphiaId: 3, scientificName: 'salmon', rank: 'Species' } };
+  it('stages provenance with types and preserves imports made while saving', () => {
+    const filters = makeTrackFilterControls();
+    filters.setTaxonomySources({ 2: { aphiaId: 2, scientificName: 'fish', rank: 'Class' } });
+    filters.importCategoryDefinitions(['salmon'], { salmon: 'fish' }, sources);
+    const patch = filters.taxonomySavePatch();
+    expect(patch.taxonomySources).toEqual({ ...filters.taxonomySources.value });
+    expect(Object.keys(patch.taxonomySources!)).toEqual(['2', '3']);
+    filters.importCategoryDefinitions(['shark'], undefined, { 4: { aphiaId: 4, scientificName: 'shark', rank: 'Species' } });
+    filters.markTaxonomyPersisted(patch);
+    expect(filters.taxonomySavePatch().taxonomySources?.['4']).toBeDefined();
+    filters.markTaxonomyPersisted(filters.taxonomySavePatch());
+    expect(filters.taxonomySavePatch()).toEqual({});
+  });
+
+  it('saves provenance once on the multicamera parent with the imported hierarchy', async () => {
+    apiMocks.saveConfig.mockReset().mockResolvedValue(undefined);
+    const saveControls = useSave(ref('multi'), ref(false));
+    saveControls.removeCamera('singleCam');
+    saveControls.addCamera('left');
+    saveControls.addCamera('right');
+    const filters = makeTrackFilterControls(saveControls.markChangesPending as MarkChangesPendingFilter);
+    filters.importCategoryDefinitions(['salmon'], { salmon: 'fish' }, sources);
+    const patch = { ...filters.typeHierarchySavePatch(), ...filters.taxonomySavePatch() };
+    const saved = await saveControls.save(patch);
+    expect(saved.canonicalConfigPersisted).toBe(true);
+    expect(apiMocks.saveConfig.mock.calls).toEqual([
+      ['multi/left', {}], ['multi/right', {}], ['multi', patch],
+    ]);
+  });
+
+  it('does not apply provenance when hierarchy validation fails', () => {
+    const filters = makeTrackFilterControls();
+    filters.setTypeHierarchy({ salmon: 'other' });
+    expect(() => filters.importCategoryDefinitions(['salmon'], { salmon: 'fish' }, sources)).toThrow();
+    expect(filters.taxonomySources.value).toEqual({});
+    expect(filters.taxonomySavePatch()).toEqual({});
+  });
+});
diff --git a/client/src/TrackFilterControls.ts b/client/src/TrackFilterControls.ts
index 82283f72d..00119937e 100644
--- a/client/src/TrackFilterControls.ts
+++ b/client/src/TrackFilterControls.ts
@@ -1,4 +1,7 @@
-import { computed, Ref, ref } from 'vue';
+import type { TaxonomySources } from 'dive-common/worms';
+import {
+  computed, markRaw, Ref, ref,
+} from 'vue';
 import { cloneDeep, isEqual } from 'lodash';
 import { clientSettings } from 'dive-common/store/settings';
 import {
@@ -6,6 +9,7 @@ import {
   normalizeTypeHierarchy,
   removeHierarchyType,
   resolveConfidenceThreshold,
+  resolveTypeHierarchy,
   rewriteHierarchyType,
   selectFlatPairIndex,
   selectPairIndex,
@@ -76,6 +80,10 @@ export default class TrackFilterControls extends BaseFilterControls<Track> {
 
   enabledFilters: Ref<boolean[]>;
 
+  taxonomySources = ref<TaxonomySources>({});
+
+  private taxonomyDirty = false;
+
   typeHierarchy: Ref<TypeHierarchy | undefined>;
 
   hierarchyIndex: Ref<TypeHierarchyIndex | undefined>;
@@ -102,6 +110,9 @@ export default class TrackFilterControls extends BaseFilterControls<Track> {
 
   constructor(params: TrackFilterControlsParams) {
     super(params);
+    // This class owns refs and computeds. Observing the instance unwraps those
+    // refs and breaks hierarchy updates when passed through reactive panel props.
+    markRaw(this);
 
     this.getTracks = params.getTracks;
     this.renameTrackPair = params.renameTrackPair;
@@ -306,6 +317,32 @@ export default class TrackFilterControls extends BaseFilterControls<Track> {
     this.hierarchyDirty = dirty;
   }
 
+  /** Validate the entire additive import before changing types or hierarchy. */
+  importCategoryDefinitions(types: string[], hierarchy?: TypeHierarchy, sources?: TaxonomySources) {
+    const resolved = resolveTypeHierarchy(this.typeHierarchy.value ?? null, true, hierarchy ?? {}, 'additive');
+    if (resolved.action === 'set' && !isEqual(resolved.hierarchy, this.typeHierarchy.value)) {
+      this.installTypeHierarchy(resolved.hierarchy, true);
+    }
+    if (sources && Object.keys(sources).length) {
+      this.taxonomySources.value = { ...this.taxonomySources.value, ...sources };
+      this.taxonomyDirty = true;
+    }
+    this.importTypes(types);
+  }
+
+  setTaxonomySources(sources?: TaxonomySources) {
+    this.taxonomySources.value = sources ?? {};
+    this.taxonomyDirty = false;
+  }
+
+  taxonomySavePatch(): { taxonomySources?: TaxonomySources } {
+    return this.taxonomyDirty ? { taxonomySources: { ...this.taxonomySources.value } } : {};
+  }
+
+  markTaxonomyPersisted(patch: { taxonomySources?: TaxonomySources }) {
+    if (isEqual(patch, this.taxonomySavePatch())) this.taxonomyDirty = false;
+  }
+
   /** Install hierarchy state loaded from a dataset or a successful config replacement. */
   setTypeHierarchy(value: unknown) {
     this.pendingLoadWarnings = [];
diff --git a/client/src/components/FilterList.spec.ts b/client/src/components/FilterList.spec.ts
index 34524593d..7d7edfe6e 100644
--- a/client/src/components/FilterList.spec.ts
+++ b/client/src/components/FilterList.spec.ts
@@ -84,11 +84,13 @@ function makeFilterListFixture({
   hierarchy = null,
   checkedTypes,
   confidenceFilters,
+  mutable = false,
 }: {
   tracks: Track[];
   hierarchy?: Record<string, string> | null;
   checkedTypes: string[];
   confidenceFilters?: Record<string, number>;
+  mutable?: boolean;
 }) {
   const cameraStore = new CameraStore({ markChangesPending: vi.fn() });
   const trackStore = cameraStore.camMap.value.get('singleCam')?.trackStore;
@@ -108,7 +110,7 @@ function makeFilterListFixture({
   filterControls.setConfidenceFilters(confidenceFilters);
   filterControls.updateCheckedTypes(checkedTypes);
   const updateCheckedTypes = vi.spyOn(filterControls, 'updateCheckedTypes');
-  Object.freeze(filterControls);
+  if (!mutable) Object.freeze(filterControls);
   const styleManager = Object.freeze({
     customStyles: ref({}),
     typeStyling: ref({
@@ -1052,3 +1054,22 @@ describe('FilterList hierarchy members', () => {
     ]);
   });
 });
+
+it('keeps the bottom list mounted when an imported hierarchy adds a shared lineage', async () => {
+  clientSettings.typeSettings.filterTypesByFrame = false;
+  const { filterControls, styleManager } = makeFilterListFixture({
+    tracks: [], checkedTypes: [], mutable: true,
+  });
+  const { wrapper, vm } = mountFilterList({
+    filterControls, styleManager, showEmptyTypes: true, height: 130, headerHeight: 50,
+  });
+  filterControls.importCategoryDefinitions(['Gadus morhua'], {
+    'Gadus morhua': 'Gadus', Gadus: 'Gadidae', Gadidae: 'Animalia', Animalia: 'Biota',
+  });
+  await nextTick();
+  expect(wrapper.find('.type-list-root').exists()).toBe(true);
+  expect(vm.sharedLineage).toEqual(['Biota', 'Animalia', 'Gadidae', 'Gadus']);
+  expect(vm.virtualTypes.map(({ type }) => type)).toEqual(['Gadus morhua']);
+  expect(vm.virtualHeight).toBeGreaterThan(0);
+  wrapper.destroy();
+});
diff --git a/client/src/components/FilterList.vue b/client/src/components/FilterList.vue
index b800638b0..a96602adf 100644
--- a/client/src/components/FilterList.vue
+++ b/client/src/components/FilterList.vue
@@ -780,6 +780,12 @@ $row-height: 30px;
   overflow: hidden;
 }
 
+.type-list-root > .container,
+.type-list-root > .input-box,
+.type-list-root > .shared-lineage {
+  flex-shrink: 0;
+}
+
 .type-list-viewport {
   flex: 1 1 0;
   min-height: 0;
diff --git a/docs/Import-Categories.md b/docs/Import-Categories.md
new file mode 100644
index 000000000..160f04f9c
--- /dev/null
+++ b/docs/Import-Categories.md
@@ -0,0 +1,111 @@
+# Importing object types
+
+In the annotation viewer, open **Type Settings** (the gear in the types list),
+then **Types**. Choose a `.txt`, `.csv`, or `.json` file, review the type and parent
+relationship preview, and click **Add**. This works in both DIVE desktop and web,
+including the sidebar and bottom panel layouts. You can also paste one type per
+line. Imported types are shown even without annotations. Save the dataset to persist
+the imported definitions.
+
+Imports add to the dataset's existing types and hierarchy. They do not import or
+modify annotations, delete existing types, or replace existing parents. Invalid
+files, cycles, and conflicting parents leave the dataset unchanged. DIVE supports
+one parent per type; multiple distinct parents are rejected.
+
+## COCO and VIAME JSON
+
+A full COCO file can be selected; only its `categories` are read. Category names
+come from `name`, and a nonempty `supercategory` specifies the parent. A `parents`
+array is used when there is no nonempty `supercategory`. A COCO `supercategory`
+identical to the category name is treated as a top-level category.
+
+```json
+{
+  "categories": [
+    { "id": 1, "name": "fish", "supercategory": "animal" },
+    { "id": 2, "name": "salmon", "parents": ["fish"] }
+  ]
+}
+```
+
+JSON may also be an array of names (`["fish", "shark"]`), an array of category
+objects, or an object with a `typeHierarchy` child-to-parent map. The map can
+accompany `categories` or appear alone:
+
+```json
+{ "typeHierarchy": { "salmon": "fish", "fish": "animal" } }
+```
+
+Parents need not have their own category records. DIVE shows them as hierarchy
+headings. COCO images, annotations, IDs, and keypoint definitions are not imported
+by this dialog.
+
+## VIAME TXT and CSV
+
+These formats follow VIAME's training label syntax: each row declares a canonical
+category followed by optional synonyms and `:parent=` fields. Extra fields are
+synonyms, not additional categories. TXT fields are separated by whitespace;
+quote names containing spaces. TXT also supports `#` comments.
+
+```text
+# Canonical category, optional synonyms, optional parent
+animal
+"sea life" marine :parent=animal
+salmon :parent="sea life"
+```
+
+CSV uses commas between fields, with standard double quoting for embedded commas,
+quotes, or newlines. No header row is required or interpreted.
+
+```csv
+animal
+sea life,marine,:parent=animal
+salmon,, :parent=sea life
+"fish, red",redfish,:parent=marine
+```
+
+Synonyms (including JSON `synonyms` arrays) are used to resolve parent references
+to canonical names during import. DIVE does not store synonym aliases; the preview
+shows a warning when the file contains them. UTF-8 files with or without a BOM,
+Windows line endings, and uppercase filename extensions are supported.
+
+## Importing directly from WoRMS
+
+In **Type Settings → Types**, choose the **WoRMS** tab. Enter at least two
+characters of a scientific name and click **Search**. You can search for a species,
+genus, family, or another taxonomic rank. Search results include the rank,
+authority, acceptance status, and a link to the corresponding WoRMS record.
+
+Select individual taxa or use **Select page**. Results are shown in pages of up to
+50 records; selections are retained when changing pages or searches. **Browse
+children** lists a taxon's immediate children, and **Back** returns to its parent
+or the original search. This does not automatically download all descendants.
+
+**Include taxonomic parent categories** is enabled by default. Click **Add** to
+resolve selected synonyms to accepted scientific names and
+retrieve the parent chains. This returns to **File or pasted list**, combining the
+WoRMS selection with any pending categories there. Review the staged types as an
+indented hierarchy tree, then click **Add** again to apply them to the dataset.
+Before the second Add, you can remove a type from the tree: that type and any
+unused parents above it are dropped, and its children become roots. Shared
+ancestors used by another remaining branch are kept. The first Add never modifies
+the dataset. Uncheck the parent option to import only the selected accepted
+names. Existing annotations are unchanged; existing hierarchy conflicts must be
+resolved before adding the import.
+
+WoRMS lookup requires internet access in both web and desktop. Requests have a
+20-second timeout and can be cancelled. An unsuccessful or cancelled preparation
+does not import a partial list. Imported types remain available offline once the
+dataset is saved; they are not automatically renamed when WoRMS changes.
+
+Dataset configuration stores the imported WoRMS AphiaIDs, original scientific
+names, and ranks in `taxonomySources`, keyed by AphiaID. Parent taxa are included
+when their hierarchy is imported. These records document the import source and
+are retained even if a type is subsequently renamed or removed. A record can be
+looked up at `https://www.marinespecies.org/aphia.php?p=taxdetails&id=APHIA_ID`.
+
+Data are supplied by the [World Register of Marine Species](https://www.marinespecies.org/)
+using its [REST webservice](https://www.marinespecies.org/rest/). Search is limited
+to marine taxa. DIVE makes bounded, user-driven requests; it does not harvest the
+whole registry. For a complete registry snapshot, WoRMS provides a separate
+[database request process](https://www.marinespecies.org/aphia.php?p=webservice).
diff --git a/docs/UI-Type-List.md b/docs/UI-Type-List.md
index f11cee0ce..43a47d359 100644
--- a/docs/UI-Type-List.md
+++ b/docs/UI-Type-List.md
@@ -134,3 +134,10 @@ Type settings also configure [suppression](UI-Suppression.md):
 * **Suppression Overlap (%)** — minimum percent of a detection that must lie under suppression regions for it to be hidden (default **99**). Shown only when a suppression type is set.
 
 The active suppression type shows an ==:material-eye-off:== icon in the type list. Detections may also be flagged with an attribute of the same name; see [Suppression](UI-Suppression.md) for region vs attribute behavior and display options.
+
+## Importing types from files
+
+Use **Type Settings → Types** to import COCO JSON or VIAME `.txt`, `.csv`, and
+`.json` category files, including parent relationships. The **WoRMS** tab searches
+marine scientific names and imports selected taxa with optional taxonomic parents. See
+[Importing object types](Import-Categories.md) for formats and examples.
diff --git a/server/dive_utils/models.py b/server/dive_utils/models.py
index 239f56903..d0139c7b7 100644
--- a/server/dive_utils/models.py
+++ b/server/dive_utils/models.py
@@ -264,6 +264,12 @@ class PairHomography(BaseModel):
 CameraRole = Literal['eo', 'ir', 'uv']
 
 
+class TaxonomySource(BaseModel):
+    aphiaId: int
+    scientificName: StrictStr
+    rank: StrictStr
+
+
 class MetadataMutable(BaseModel):
     version = (
         constants.JsonMetaCurrentVersion
@@ -277,6 +283,7 @@ class MetadataMutable(BaseModel):
     attributeTrackFilters: Optional[Dict[str, AttributeTrackFilter]]
     datasetInfo: Optional[types.DatasetInfo]
     typeHierarchy: Optional[TypeHierarchy] = None
+    taxonomySources: Optional[Dict[str, TaxonomySource]] = None
     # Per-camera-pair alignment homographies, keyed by directional "left::right".
     # Each value holds the 3x3 AtoB / BtoA matrices.
     cameraHomographies: Optional[Dict[str, PairHomography]]
diff --git a/server/tests/test_update_metadata.py b/server/tests/test_update_metadata.py
index df510804d..6523110cf 100644
--- a/server/tests/test_update_metadata.py
+++ b/server/tests/test_update_metadata.py
@@ -1083,3 +1083,19 @@ def test_get_multicam_camera_name_returns_matching_camera():
     assert crud.get_multicam_camera_name({'_id': 'left-id'}, parent) == 'left'
     assert crud.get_multicam_camera_name({'_id': 'right-id'}, parent) == 'right'
     assert crud.get_multicam_camera_name({'_id': 'other-id'}, parent) is None
+
+
+@patch('dive_server.crud.Folder')
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.crud.verify_dataset')
+def test_update_metadata_preserves_worms_provenance(_verify, folder_cls, crud_folder_cls):
+    folder = {'_id': 'dataset-id', 'meta': {'annotate': True, 'type': 'video'}}
+    _stub_folder_load_and_save(folder_cls, folder)
+    _stub_folder_load_and_save(crud_folder_cls, folder)
+    sources = {'126175': {'aphiaId': 126175, 'scientificName': 'Sebastes', 'rank': 'Genus'}}
+    crud_dataset.update_metadata(folder, {'taxonomySources': sources})
+    assert folder['meta']['taxonomySources'] == sources
+    crud_dataset.update_metadata(folder, {'confidenceFilters': {'default': 0.5}})
+    assert folder['meta']['taxonomySources'] == sources
+    validated = models.MetadataMutable(**folder['meta'])
+    assert validated.dict(exclude_none=True)['taxonomySources'] == sources