@glossarist/concept-browser 0.7.51 → 0.7.52

package/src/__tests__/__fixtures__/concepts.ts

@@ -0,0 +1,221 @@
+import { Concept } from 'glossarist';
+
+export interface ConceptFixture {
+  readonly name: string;
+  readonly description: string;
+  readonly uri: string;
+  readonly concept: Concept;
+}
+
+const BASE = 'https://glossarist.org/fixtures/concept';
+
+function minimal(): Concept {
+  return Concept.fromJSON({
+    id: '1.1',
+    uri: `${BASE}/minimal`,
+    status: 'valid',
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: 'minimal concept', normative_status: 'preferred' }],
+        definition: [{ content: 'A minimal concept used to verify the baseline emission path.' }],
+      },
+    },
+  });
+}
+
+function multilingual(): Concept {
+  return Concept.fromJSON({
+    id: '2.1',
+    uri: `${BASE}/multilingual`,
+    status: 'valid',
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: 'coordinate system', normative_status: 'preferred' }],
+        definition: [{ content: 'A system for specifying positions in space.' }],
+      },
+      fra: {
+        language_code: 'fra',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: 'système de coordonnées', normative_status: 'preferred' }],
+        definition: [{ content: 'Un système pour spécifier des positions dans l’espace.' }],
+      },
+      jpn: {
+        language_code: 'jpn',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: '座標系', normative_status: 'preferred' }],
+        definition: [{ content: '空間における位置を指定するための体系。' }],
+      },
+    },
+  });
+}
+
+function fullRelationships(): Concept {
+  return Concept.fromJSON({
+    id: '3.1',
+    uri: `${BASE}/full-relationships`,
+    status: 'valid',
+    related: [
+      { type: 'supersedes',     content: 'Replaces older term.', ref: { source: 'IEC', id: '60050-3.1.1' } },
+      { type: 'superseded_by',  content: 'Superseded by newer.', ref: { source: 'ISO', id: '9999-1.2.3' } },
+      { type: 'derived',        content: 'Derived from source.', ref: { source: 'VIM', id: '1.1'          } },
+      { type: 'compare',        content: 'Compare with similar.', ref: { source: 'IEV', id: '102-01-01'  } },
+      { type: 'contrast',       content: 'Contrast with this.',  ref: { source: 'IEV', id: '102-02-02'  } },
+    ],
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: 'related concept hub', normative_status: 'preferred' }],
+        definition: [{ content: 'A concept that demonstrates every relationship type.' }],
+      },
+    },
+  });
+}
+
+function withSources(): Concept {
+  return Concept.fromJSON({
+    id: '4.1',
+    uri: `${BASE}/with-sources`,
+    status: 'valid',
+    sources: [
+      {
+        status: 'identical',
+        type: 'authoritative',
+        modification: 'revised 2024',
+        origin: {
+          ref: { source: 'ISO 704', id: '3.1', version: '2020' },
+          locality: { type: 'clause', referenceFrom: '3.1', referenceTo: '3.5' },
+          link: 'https://example.org/iso-704',
+          original: 'Original wording here.',
+        },
+      },
+      {
+        status: 'modified',
+        type: 'lineage',
+        origin: {
+          ref: { source: 'IEC 60050', id: '102-01', version: '2008' },
+          locality: { type: 'clause', referenceFrom: '102-01-01' },
+        },
+      },
+      {
+        status: 'restyled',
+        type: 'lineage',
+        origin: {
+          ref: { source: 'VIM', id: '1.2', version: '2012' },
+        },
+      },
+    ],
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: 'cited term', normative_status: 'preferred' }],
+        definition: [{ content: 'A concept that carries structured citations.' }],
+        sources: [
+          {
+            status: 'identical',
+            type: 'authoritative',
+            origin: {
+              ref: { source: 'ISO 1087', id: '2.1', version: '2019' },
+              locality: { type: 'clause', referenceFrom: '2.1' },
+            },
+          },
+        ],
+      },
+    },
+  });
+}
+
+function withNonVerbal(): Concept {
+  return Concept.fromJSON({
+    id: '5.1',
+    uri: `${BASE}/with-non-verbal`,
+    status: 'valid',
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: 'angle of repose', normative_status: 'preferred' }],
+        definition: [{ content: 'The steepest angle relative to the horizontal at which a material can be piled without sliding.' }],
+        non_verbal_rep: [
+          {
+            type: 'figure',
+            caption: 'Angle of repose diagram',
+            description: 'Schematic diagram showing the angle.',
+            images: [{ src: 'https://glossarist.org/figs/angle.svg' }],
+          },
+          {
+            type: 'formula',
+            caption: 'tan(θ) = μ',
+          },
+          {
+            type: 'table',
+            caption: 'Measured angles',
+            description: 'Empirical values across materials.',
+          },
+        ],
+      },
+    },
+  });
+}
+
+function withDates(): Concept {
+  return Concept.fromJSON({
+    id: '6.1',
+    uri: `${BASE}/with-dates`,
+    status: 'valid',
+    dates: [
+      { type: 'accepted', date: '2020-01-15' },
+      { type: 'amended',  date: '2023-06-30' },
+      { type: 'retired',  date: '2025-12-31' },
+    ],
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: 'lifecycle concept', normative_status: 'preferred' }],
+        definition: [{ content: 'A concept that exercises the accepted/amended/retired date types.' }],
+      },
+    },
+  });
+}
+
+function withdrawnConcept(): Concept {
+  return Concept.fromJSON({
+    id: '7.1',
+    uri: `${BASE}/withdrawn`,
+    status: 'withdrawn',
+    dates: [
+      { type: 'accepted', date: '2018-03-01' },
+      { type: 'retired',  date: '2024-09-15' },
+    ],
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'withdrawn',
+        terms: [{ type: 'expression', designation: 'withdrawn concept', normative_status: 'preferred' }],
+        definition: [{ content: 'A withdrawn concept with a retirement date.' }],
+      },
+    },
+  });
+}
+
+export const CONCEPT_FIXTURES: readonly ConceptFixture[] = [
+  { name: 'minimal',            description: 'one localization, one designation',                uri: `${BASE}/minimal`,            concept: minimal() },
+  { name: 'multilingual',       description: 'three languages across Latn and CJK scripts',      uri: `${BASE}/multilingual`,       concept: multilingual() },
+  { name: 'full-relationships', description: 'every supported related-concept type',             uri: `${BASE}/full-relationships`, concept: fullRelationships() },
+  { name: 'with-sources',       description: 'structured citations, locality, original wording', uri: `${BASE}/with-sources`,       concept: withSources() },
+  { name: 'with-non-verbal',    description: 'figure, formula, and table non-verbal reps',       uri: `${BASE}/with-non-verbal`,    concept: withNonVerbal() },
+  { name: 'with-dates',         description: 'accepted/amended/retired lifecycle',               uri: `${BASE}/with-dates`,         concept: withDates() },
+  { name: 'withdrawn',          description: 'withdrawn status with retirement date (J3)',        uri: `${BASE}/withdrawn`,          concept: withdrawnConcept() },
+];
+
+export function fixtureByName(name: string): ConceptFixture {
+  const f = CONCEPT_FIXTURES.find(f => f.name === name);
+  if (!f) throw new Error(`Unknown concept fixture: ${name}`);
+  return f;
+}

package/src/__tests__/adapters/concept-identity.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { ConceptIdentity } from '../../adapters/concept-identity';
+import { InvalidConceptIdentityError, InvalidConceptUriError } from '../../errors';
+
+describe('ConceptIdentity', () => {
+  it('derives uri, slug, and path from parts', () => {
+    const id = new ConceptIdentity('3.1.1', 'iso-10303-2', 'https://glossarist.org');
+    expect(id.uri).toBe('https://glossarist.org/iso-10303-2/concept/3.1.1');
+    expect(id.slug).toBe('3.1.1');
+    expect(id.path).toBe('iso-10303-2/concepts/3.1.1');
+  });
+
+  it('rejects empty parts with a typed SerializationError', () => {
+    expect(() => new ConceptIdentity('', 'r', 'b')).toThrow(InvalidConceptIdentityError);
+    expect(() => new ConceptIdentity('x', '', 'b')).toThrow(InvalidConceptIdentityError);
+    expect(() => new ConceptIdentity('x', 'r', '')).toThrow(InvalidConceptIdentityError);
+  });
+
+  it('equals another identity with the same URI', () => {
+    const a = new ConceptIdentity('1', 'r', 'https://glossarist.org');
+    const b = new ConceptIdentity('1', 'r', 'https://glossarist.org');
+    expect(a.equals(b)).toBe(true);
+  });
+
+  it('does not equal an identity with a different local id', () => {
+    const a = new ConceptIdentity('1', 'r', 'https://glossarist.org');
+    const b = new ConceptIdentity('2', 'r', 'https://glossarist.org');
+    expect(a.equals(b)).toBe(false);
+  });
+
+  it('round-trips through fromUri', () => {
+    const original = new ConceptIdentity('3.1.1', 'iso-10303-2', 'https://glossarist.org');
+    const roundTrip = ConceptIdentity.fromUri(original.uri);
+    expect(roundTrip.equals(original)).toBe(true);
+  });
+
+  it('fromUri rejects non-concept URIs with a typed error', () => {
+    expect(() => ConceptIdentity.fromUri('https://example.org/foo/bar')).toThrow(InvalidConceptUriError);
+  });
+
+  it('isConceptUri recognizes canonical URIs', () => {
+    expect(ConceptIdentity.isConceptUri('https://glossarist.org/iso-10303-2/concept/3.1.1')).toBe(true);
+    expect(ConceptIdentity.isConceptUri('https://example.org')).toBe(false);
+  });
+
+  it('localizationUri follows the canonical sub-resource pattern', () => {
+    const id = new ConceptIdentity('3.1.1', 'iso-10303-2', 'https://glossarist.org');
+    expect(id.localizationUri('eng')).toBe('https://glossarist.org/iso-10303-2/concept/3.1.1/eng');
+  });
+
+  it('designationUri composes localization + desig slugs', () => {
+    const id = new ConceptIdentity('3.1.1', 'iso-10303-2', 'https://glossarist.org');
+    expect(id.designationUri('eng', 'atomic_data_unit')).toBe(
+      'https://glossarist.org/iso-10303-2/concept/3.1.1/eng/desig/atomic_data_unit',
+    );
+  });
+
+  it('domainUri follows the register-scoped pattern', () => {
+    const id = new ConceptIdentity('3.1.1', 'iso-10303-2', 'https://glossarist.org');
+    expect(id.domainUri('geometry')).toBe('https://glossarist.org/iso-10303-2/domain/geometry');
+  });
+
+  it('toString returns the URI for logging', () => {
+    const id = new ConceptIdentity('3.1.1', 'iso-10303-2', 'https://glossarist.org');
+    expect(`${id}`).toBe('https://glossarist.org/iso-10303-2/concept/3.1.1');
+  });
+
+  it('toJSON serializes the parts', () => {
+    const id = new ConceptIdentity('3.1.1', 'iso-10303-2', 'https://glossarist.org');
+    expect(id.toJSON()).toEqual({
+      localId: '3.1.1',
+      registerId: 'iso-10303-2',
+      uriBase: 'https://glossarist.org',
+    });
+  });
+});

package/src/__tests__/components/error-boundary.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { h, defineComponent, ref, computed } from 'vue';
+import ErrorBoundary from '../../components/ErrorBoundary.vue';
+import { ConceptNotFoundError, GlossaristError } from '../../errors';
+
+const Bomb = defineComponent({
+  name: 'Bomb',
+  props: { error: { type: Object as () => Error | undefined, default: undefined } },
+  setup(props) {
+    return () => {
+      if (props.error) throw props.error;
+      return h('p', 'all good');
+    };
+  },
+});
+
+function mountBoundary(initialError?: Error) {
+  const holder = ref<Error | undefined>(initialError);
+  const wrapper = mount(ErrorBoundary, {
+    props: {},
+    slots: { default: () => h(Bomb, { error: holder.value }) },
+  });
+  return { wrapper, holder };
+}
+
+describe('ErrorBoundary', () => {
+  it('renders the slot when no error is thrown', () => {
+    const wrapper = mount(ErrorBoundary, {
+      props: {},
+      slots: { default: () => h('p', 'all good') },
+    });
+    expect(wrapper.text()).toContain('all good');
+    expect(wrapper.find('[role="alert"]').exists()).toBe(false);
+  });
+
+  it('catches a child error and renders the fallback', async () => {
+    const { wrapper, holder } = mountBoundary();
+    holder.value = new Error('boom');
+    await wrapper.vm.$nextTick();
+    expect(wrapper.text()).toContain('boom');
+    expect(wrapper.find('[role="alert"]').exists()).toBe(true);
+  });
+
+  it('uses the custom title when provided', async () => {
+    const wrapper = mount(ErrorBoundary, {
+      props: { title: 'Concept failed' },
+      slots: { default: () => h('p', 'ok') },
+    });
+    expect(wrapper.find('h3').exists()).toBe(false);
+
+    const holder = ref<Error | undefined>();
+    const w2 = mount(ErrorBoundary, {
+      props: { title: 'Concept failed' },
+      slots: { default: () => h(Bomb, { error: holder.value }) },
+    });
+    holder.value = new Error('x');
+    await w2.vm.$nextTick();
+    expect(w2.find('h3').text()).toBe('Concept failed');
+  });
+
+  it('emits an error event with the captured value', async () => {
+    const { wrapper, holder } = mountBoundary();
+    holder.value = new Error('boom');
+    await wrapper.vm.$nextTick();
+    const evt = wrapper.emitted('error');
+    expect(evt).toBeDefined();
+    expect(evt?.[0]?.[0]).toBeInstanceOf(Error);
+  });
+
+  it('shows details block for GlossaristError instances', async () => {
+    const holder = ref<Error | undefined>();
+    const wrapper = mount(ErrorBoundary, {
+      props: {},
+      slots: { default: () => h(Bomb, { error: holder.value }) },
+    });
+    holder.value = ConceptNotFoundError.make('iso1', '3.1.1');
+    await wrapper.vm.$nextTick();
+    expect(wrapper.find('details').exists()).toBe(true);
+    expect(wrapper.text()).toContain('ConceptNotFoundError');
+  });
+
+  it('hides details for plain Errors (no context to show)', async () => {
+    const holder = ref<Error | undefined>();
+    const wrapper = mount(ErrorBoundary, {
+      props: {},
+      slots: { default: () => h(Bomb, { error: holder.value }) },
+    });
+    holder.value = new Error('plain');
+    await wrapper.vm.$nextTick();
+    expect(wrapper.find('details').exists()).toBe(false);
+  });
+
+  it('exposes a retryKey data attribute when provided', async () => {
+    const holder = ref<Error | undefined>();
+    const wrapper = mount(ErrorBoundary, {
+      props: { retryKey: 'concept-3.1.1' },
+      slots: { default: () => h(Bomb, { error: holder.value }) },
+    });
+    holder.value = new Error('boom');
+    await wrapper.vm.$nextTick();
+    expect(wrapper.find('[data-retry-key="concept-3.1.1"]').exists()).toBe(true);
+  });
+
+  it('GlossaristError is recognized as GlossaristError (sanity)', () => {
+    const err = ConceptNotFoundError.make('r', 'c');
+    expect(err).toBeInstanceOf(GlossaristError);
+  });
+});

package/src/__tests__/composables/use-dataset-series.test.ts

@@ -0,0 +1,262 @@
+import { describe, it, expect } from 'vitest';
+import { extractYear, deriveSeriesKey, groupManifestsIntoSeries } from '../../composables/useDatasetSeries';
+import type { Manifest } from '../../adapters/types';
+
+function makeManifest(overrides: Partial<Manifest> = {}): Manifest {
+  return {
+    id: 'test',
+    title: 'Test',
+    ref: 'TEST',
+    conceptCount: 0,
+    languages: ['eng'],
+    sections: [],
+    status: 'valid',
+    schemaVersion: '1.0',
+    lastUpdated: '2026-01-01',
+    ...overrides,
+  } as unknown as Manifest;
+}
+
+describe('extractYear — ISO standard references', () => {
+  it('extracts the year from `:YYYY` ISO references', () => {
+    expect(extractYear('ISO 10241-1:2011')).toBe(2011);
+    expect(extractYear('ISO/IEC 11179-1:2015')).toBe(2015);
+    expect(extractYear('ISO 19115:2003')).toBe(2003);
+    expect(extractYear('IEC 60050-102:2017')).toBe(2017);
+  });
+
+  it('extracts the year from `:YYYYa` ISO references (revision letter)', () => {
+    expect(extractYear('ISO 123:2020a')).toBe(2020);
+    expect(extractYear('ISO 123:2018A')).toBe(2018);
+  });
+
+  it('does NOT match a 4-digit standard number without a colon', () => {
+    expect(extractYear('ISO 10241')).toBeUndefined();
+    expect(extractYear('ISO 19115')).toBeUndefined();
+    expect(extractYear('IEC 60050')).toBeUndefined();
+  });
+});
+
+describe('extractYear — naming-convention suffix', () => {
+  it('extracts the year from `<name>-YYYY` suffix', () => {
+    expect(extractYear('viml-2022')).toBe(2022);
+    expect(extractYear('viml-1968')).toBe(1968);
+  });
+
+  it('extracts the year from `<name>_YYYY` suffix', () => {
+    expect(extractYear('viml_2022')).toBe(2022);
+  });
+
+  it('extracts the year from `<name> YYYY` suffix', () => {
+    expect(extractYear('VIML 1968')).toBe(1968);
+  });
+
+  it('extracts the year with revision letter', () => {
+    expect(extractYear('viml-2022a')).toBe(2022);
+    expect(extractYear('viml-2022A')).toBe(2022);
+  });
+});
+
+describe('extractYear — bare year', () => {
+  it('extracts a bare 4-digit year as the entire string', () => {
+    expect(extractYear('2022')).toBe(2022);
+    expect(extractYear('  1968  ')).toBe(1968);
+  });
+});
+
+describe('extractYear — rejection cases', () => {
+  it('returns undefined for strings with no year', () => {
+    expect(extractYear('VIM')).toBeUndefined();
+    expect(extractYear('ISO')).toBeUndefined();
+    expect(extractYear('')).toBeUndefined();
+  });
+
+  it('returns undefined for 4-digit runs that are out of range', () => {
+    expect(extractYear('file-1800')).toBeUndefined();
+    expect(extractYear('file-2200')).toBeUndefined();
+  });
+
+  it('handles ambiguous strings by preferring ISO `:YYYY` form', () => {
+    expect(extractYear('ISO 704:2020 and ISO 10241:2011')).toBe(2011);
+  });
+});
+
+describe('deriveSeriesKey', () => {
+  it('strips trailing -YYYY', () => {
+    expect(deriveSeriesKey('viml-2022')).toBe('viml');
+    expect(deriveSeriesKey('viml-1968')).toBe('viml');
+  });
+
+  it('strips trailing _YYYY', () => {
+    expect(deriveSeriesKey('viml_2022')).toBe('viml');
+  });
+
+  it('strips trailing :YYYY', () => {
+    expect(deriveSeriesKey('iso-704:2020')).toBe('iso-704');
+  });
+
+  it('preserves keys without year suffix', () => {
+    expect(deriveSeriesKey('iso-704')).toBe('iso-704');
+    expect(deriveSeriesKey('viml')).toBe('viml');
+  });
+
+  it('handles year+letter suffix', () => {
+    expect(deriveSeriesKey('viml-2022a')).toBe('viml');
+  });
+});
+
+describe('groupManifestsIntoSeries', () => {
+  describe('strategy 1 — config-driven lineage series', () => {
+    it('uses config when at least one lineage group is configured', () => {
+      const manifests = [
+        makeManifest({ id: 'viml-2022', status: 'valid' }),
+        makeManifest({ id: 'viml-2013', status: 'valid' }),
+      ];
+      const configured = [{
+        id: 'viml',
+        label: 'VIML',
+        datasets: ['viml-2022', 'viml-2013'],
+        kind: 'lineage' as const,
+      }];
+      const series = groupManifestsIntoSeries(manifests, undefined, configured);
+      expect(series.length).toBe(1);
+      expect(series[0].key).toBe('viml');
+      expect(series[0].members.length).toBe(2);
+      expect(series[0].configured).toBe(true);
+    });
+
+    it('includes stub members for datasets whose manifest is not loaded', () => {
+      const manifests = [makeManifest({ id: 'viml-2022', status: 'valid' })];
+      const configured = [{
+        id: 'viml',
+        datasets: ['viml-2022', 'viml-2013', 'viml-1968'],
+        kind: 'lineage' as const,
+      }];
+      const series = groupManifestsIntoSeries(manifests, undefined, configured);
+      expect(series[0].members.length).toBe(3);
+    });
+
+    it('honors explicit current from config', () => {
+      const manifests = [
+        makeManifest({ id: 'viml-2022', status: 'valid' }),
+        makeManifest({ id: 'viml-2013', status: 'valid' }),
+      ];
+      const configured = [{
+        id: 'viml',
+        datasets: ['viml-2013', 'viml-2022'],
+        kind: 'lineage' as const,
+        current: 'viml-2013',
+      }];
+      const series = groupManifestsIntoSeries(manifests, undefined, configured);
+      expect(series[0].current?.id).toBe('viml-2013');
+    });
+
+    it('falls back to newest valid member when current is unset', () => {
+      const manifests = [
+        makeManifest({ id: 'viml-2022', status: 'valid' }),
+        makeManifest({ id: 'viml-2013', status: 'valid' }),
+      ];
+      const configured = [{
+        id: 'viml',
+        datasets: ['viml-2013', 'viml-2022'],
+        kind: 'lineage' as const,
+      }];
+      const series = groupManifestsIntoSeries(manifests, undefined, configured);
+      expect(series[0].current?.id).toBe('viml-2022');
+    });
+
+    it('sorts members by year ascending', () => {
+      const manifests = [
+        makeManifest({ id: 'viml-2022', status: 'valid' }),
+        makeManifest({ id: 'viml-1968', status: 'withdrawn' }),
+        makeManifest({ id: 'viml-2013', status: 'valid' }),
+      ];
+      const configured = [{
+        id: 'viml',
+        datasets: ['viml-2022', 'viml-1968', 'viml-2013'],
+        kind: 'lineage' as const,
+      }];
+      const series = groupManifestsIntoSeries(manifests, undefined, configured);
+      const years = series[0].members.map(m => m.year);
+      expect(years).toEqual([1968, 2013, 2022]);
+    });
+  });
+
+  describe('strategy 2 — auto-derive by naming convention', () => {
+    it('groups by stripped key when no config is provided', () => {
+      const manifests = [
+        makeManifest({ id: 'viml-2022', status: 'valid' }),
+        makeManifest({ id: 'viml-2013', status: 'valid' }),
+        makeManifest({ id: 'iso-geodetic', status: 'valid' }),
+      ];
+      const series = groupManifestsIntoSeries(manifests, undefined, []);
+      expect(series.length).toBe(2);
+      const viml = series.find(s => s.key === 'viml');
+      expect(viml?.members.length).toBe(2);
+      expect(viml?.configured).toBe(false);
+    });
+
+    it('sorts groups alphabetically', () => {
+      const manifests = [
+        makeManifest({ id: 'viml-2022' }),
+        makeManifest({ id: 'iso-geodetic' }),
+      ];
+      const series = groupManifestsIntoSeries(manifests, undefined, []);
+      expect(series.map(s => s.key)).toEqual(['iso-geodetic', 'viml']);
+    });
+
+    it('picks newest valid as current in auto-derived mode', () => {
+      const manifests = [
+        makeManifest({ id: 'viml-2013', status: 'valid' }),
+        makeManifest({ id: 'viml-2022', status: 'valid' }),
+      ];
+      const series = groupManifestsIntoSeries(manifests, undefined, []);
+      expect(series[0].current?.id).toBe('viml-2022');
+    });
+  });
+
+  describe('strategy selection', () => {
+    it('picks strategy 1 when at least one configured lineage group exists', () => {
+      const manifests = [
+        makeManifest({ id: 'viml-2022' }),
+        makeManifest({ id: 'viml-2013' }),
+        makeManifest({ id: 'iso-geodetic' }),
+      ];
+      const configured = [{
+        id: 'viml',
+        datasets: ['viml-2022', 'viml-2013'],
+        kind: 'lineage' as const,
+      }];
+      const series = groupManifestsIntoSeries(manifests, undefined, configured);
+      // Strategy 1 → only `viml` group, no auto-derive
+      expect(series.length).toBe(1);
+      expect(series[0].key).toBe('viml');
+    });
+
+    it('falls through to strategy 2 when no configured lineage groups exist', () => {
+      const manifests = [
+        makeManifest({ id: 'viml-2022' }),
+        makeManifest({ id: 'viml-2013' }),
+      ];
+      const configured = [{
+        id: 'topic-group',
+        datasets: ['viml-2022', 'viml-2013'],
+        kind: 'topic' as const,
+      }];
+      const series = groupManifestsIntoSeries(manifests, undefined, configured);
+      expect(series.some(s => !s.configured)).toBe(true);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('empty manifests array returns empty series array', () => {
+      expect(groupManifestsIntoSeries([], undefined, [])).toEqual([]);
+    });
+
+    it('empty config falls through to strategy 2', () => {
+      const manifests = [makeManifest({ id: 'viml-2022' }), makeManifest({ id: 'viml-2013' })];
+      const series = groupManifestsIntoSeries(manifests, undefined, []);
+      expect(series[0].key).toBe('viml');
+    });
+  });
+});