@glossarist/concept-browser 0.7.138 → 0.7.140

package/src/__tests__/dataset-adapter.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { DatasetAdapter } from '../adapters/DatasetAdapter';
+import { ChunkLoadError } from '../errors';
 import { conceptFromJson } from '../adapters/model-bridge';
 
 // Mock fetch globally
@@ -132,6 +133,127 @@ describe('DatasetAdapter', () => {
     });
   });
 
+  describe('chunk URLs', () => {
+    it.each([undefined, 'abc123def456'])('uses metadata filenames and optional hash %s for summary chunks', async (hash) => {
+      adapter.manifest = { conceptCount: 1001 } as any;
+      const first = { id: 'first', designations: { eng: 'First' }, status: 'valid' };
+      const last = { id: 'last', designations: { eng: 'Last' }, status: 'valid' };
+      mockFetch
+        .mockReturnValueOnce(mockJsonResponse({
+          registerId: 'test', schemaVersion: '1.0.0', conceptCount: 1001, chunkSize: 1000,
+          chunks: [
+            { file: 'first.json', count: 1000, hash },
+            { file: 'last.json', count: 1, hash },
+          ],
+        }))
+        .mockReturnValueOnce(mockJsonResponse({ concepts: [first] }))
+        .mockReturnValueOnce(mockJsonResponse({ concepts: [last] }));
+
+      await adapter.loadIndex();
+      await adapter.ensureAllChunksLoaded();
+
+      const query = hash ? `?v=${hash}` : '';
+      expect(mockFetch.mock.calls.map(([url]) => url)).toEqual([
+        '/data/test/index-meta.json',
+        `/data/test/chunks/first.json${query}`,
+        `/data/test/chunks/last.json${query}`,
+      ]);
+      expect(adapter.getIndexEntry('first')).toMatchObject(first);
+      expect(adapter.getIndexEntry('last')).toMatchObject(last);
+    });
+
+    it.each([undefined, 'abc123def456'])('uses index metadata and optional hash %s for full chunks', async (hash) => {
+      const entry = { id: 'first', designations: { eng: 'First' }, status: 'valid' };
+      mockFetch
+        .mockReturnValueOnce(mockJsonResponse({
+          registerId: 'test', schemaVersion: '1.0.0', conceptCount: 1, chunkSize: 1000,
+          chunks: [{ file: 'custom.json', count: 1, hash }], concepts: [entry],
+        }))
+        .mockReturnValueOnce(mockJsonResponse({ concepts: [entry] }));
+
+      await adapter.loadIndex();
+      expect(await adapter.loadChunk(0)).toEqual([entry]);
+      expect(mockFetch).toHaveBeenLastCalledWith(`/data/test/chunks/custom.json${hash ? `?v=${hash}` : ''}`);
+      expect(await adapter.loadChunk(0)).toEqual([]);
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+    });
+
+    it('keeps the legacy filename when no index metadata is available', async () => {
+      mockFetch.mockReturnValueOnce(mockJsonResponse({ concepts: [] }));
+      await adapter.loadChunk(2);
+      expect(mockFetch).toHaveBeenCalledWith('/data/test/chunks/index-0002.json');
+    });
+  });
+
+  describe('chunked index failures', () => {
+    it('rejects loadIndex when its first chunk fails and allows a retry', async () => {
+      adapter.manifest = { conceptCount: 1001 } as any;
+      const meta = {
+        registerId: 'test', schemaVersion: '1.0.0', conceptCount: 1001, chunkSize: 1000,
+        chunks: [{ file: 'index-0000.json', count: 1000 }, { file: 'index-0001.json', count: 1 }],
+      };
+      mockFetch
+        .mockReturnValueOnce(mockJsonResponse(meta))
+        .mockResolvedValueOnce({ ok: false, status: 404 } as Response);
+
+      await expect(adapter.loadIndex()).rejects.toBeInstanceOf(ChunkLoadError);
+      expect(adapter.isRangeLoaded(0, 1)).toBe(false);
+
+      mockFetch
+        .mockReturnValueOnce(mockJsonResponse(meta))
+        .mockReturnValueOnce(mockJsonResponse({ concepts: [
+          { id: 'first', designations: { eng: 'First' }, status: 'valid' },
+        ] }));
+      await adapter.loadIndex();
+
+      expect(adapter.isRangeLoaded(0, 1)).toBe(true);
+      expect(adapter.getIndexEntry('first')?.eng).toBe('First');
+      expect(mockFetch).toHaveBeenNthCalledWith(4, '/data/test/chunks/index-0000.json');
+    });
+
+    it.each(['all', 'range'] as const)('rejects a missing chunk and retries it when loading %s chunks', async (mode) => {
+      adapter.manifest = { conceptCount: 1002 } as any;
+      const first = { id: 'first', designations: { eng: 'First' }, status: 'valid' };
+      const missing = { id: 'missing', designations: { eng: 'Recovered' }, status: 'valid' };
+      mockFetch
+        .mockReturnValueOnce(mockJsonResponse({
+          registerId: 'test', schemaVersion: '1.0.0', conceptCount: 1002, chunkSize: 1000,
+          chunks: [{ file: 'index-0000.json', count: 1000 }, { file: 'index-0001.json', count: 2 }],
+        }))
+        .mockReturnValueOnce(mockJsonResponse({ concepts: [first] }))
+        .mockResolvedValueOnce({ ok: false, status: 404 } as Response);
+      await adapter.loadIndex();
+      const ensureLoaded = () => mode === 'all'
+        ? adapter.ensureAllChunksLoaded()
+        : adapter.ensureChunksForRange(1000, 2);
+
+      const failedLoad = ensureLoaded();
+      await expect(failedLoad).rejects.toBeInstanceOf(ChunkLoadError);
+      await expect(failedLoad).rejects.toMatchObject({
+        context: { registerId: 'test', chunkIndex: 1, status: 404 },
+      });
+      expect(adapter.isRangeLoaded(1000, 2)).toBe(false);
+      expect(adapter.getIndexEntry('missing')).toBeUndefined();
+      expect(adapter.getIndexEntry('first')).toMatchObject(first);
+
+      mockFetch.mockReturnValueOnce(mockJsonResponse({ concepts: [
+        missing, { id: 'last', designations: { eng: 'Last' }, status: 'valid' },
+      ] }));
+      await ensureLoaded();
+
+      expect(adapter.isRangeLoaded(1000, 2)).toBe(true);
+      expect(adapter.index?.concepts.slice(1000)).toMatchObject([missing, { id: 'last' }]);
+      expect(adapter.getIndexEntry('missing')).toMatchObject(missing);
+      expect(adapter.getIndexEntry('first')).toMatchObject(first);
+      expect(mockFetch.mock.calls.map(([url]) => url)).toEqual([
+        '/data/test/index-meta.json', '/data/test/chunks/index-0000.json',
+        '/data/test/chunks/index-0001.json', '/data/test/chunks/index-0001.json',
+      ]);
+      await ensureLoaded();
+      expect(mockFetch).toHaveBeenCalledTimes(4);
+    });
+  });
+
   describe('fetchConcept', () => {
     it('fetches and caches concept documents', async () => {
       const concept = {
@@ -218,6 +340,34 @@ describe('DatasetAdapter', () => {
       expect(hits[0].conceptId).toBe('103-01-02');
     });
 
+    it('carries concept status on designation and ID search hits', async () => {
+      const index = {
+        registerId: 'test',
+        schemaVersion: '1.0.0',
+        conceptCount: 2,
+        chunkSize: 500,
+        chunks: [],
+        concepts: [
+          { id: '102-01-01', designations: { eng: 'shared term' }, eng: 'shared term', status: 'valid' },
+          { id: '102-01-02', designations: { eng: 'shared term' }, eng: 'shared term', status: 'superseded' },
+        ],
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(index));
+      await adapter.loadIndex();
+
+      const designationHits = adapter.search('shared term');
+      expect(Object.fromEntries(designationHits.map(({ conceptId, status }) => [conceptId, status]))).toEqual({
+        '102-01-01': 'valid',
+        '102-01-02': 'superseded',
+      });
+
+      const idHits = ['102-01-01', '102-01-02'].flatMap((id) => adapter.search(id));
+      expect(Object.fromEntries(idHits.map(({ conceptId, status }) => [conceptId, status]))).toEqual({
+        '102-01-01': 'valid',
+        '102-01-02': 'superseded',
+      });
+    });
+
     it('is case insensitive', async () => {
       const index = {
         registerId: 'test',
@@ -548,7 +698,7 @@ describe('DatasetAdapter', () => {
       expect(edges.length).toBe(2);
       expect(edges.every(e => e.type === 'domain')).toBe(true);
       expect(edges.find(e => e.lang === 'eng')?.target).toContain('/domain/geometry');
-      expect(edges.find(e => e.lang === 'fra')?.target).toContain('/domain/gomtrie');
+      expect(edges.find(e => e.lang === 'fra')?.target).toContain('/domain/géométrie');
       expect(edges.find(e => e.lang === 'eng')?.label).toBe('geometry');
       expect(edges.find(e => e.lang === 'fra')?.label).toBe('géométrie');
     });

package/src/__tests__/dataset-view.test.ts

@@ -1,10 +1,11 @@
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { mount, flushPromises } from '@vue/test-utils';
 import { createPinia, setActivePinia } from 'pinia';
 import { createRouter, createMemoryHistory } from 'vue-router';
 import DatasetView from '../views/DatasetView.vue';
 import { useVocabularyStore } from '../stores/vocabulary';
 import type { Manifest, ConceptSummary, SectionNode } from '../adapters/types';
+import { ChunkLoadError } from '../errors';
 
 function makeManifest(overrides: Partial<Manifest> = {}): Manifest {
   return {
@@ -137,6 +138,45 @@ describe('DatasetView', () => {
     expect(wrapper.text()).toContain('Next');
   });
 
+  it.each(['page', 'filter'] as const)('shows a chunk failure instead of remaining loading after a %s change', async (action) => {
+    const store = useVocabularyStore();
+    const adapter = makeAdapter(makeConcepts(120));
+    const error = ChunkLoadError.make('test', 1, 503);
+    let failing = true;
+    adapter.isRangeLoaded = (start: number) => start === 0;
+    adapter.ensureChunksForRange = vi.fn(async () => { if (failing) throw error; });
+    adapter.ensureAllChunksLoaded = vi.fn(async () => { if (failing) throw error; });
+    store.manifests.set('test', makeManifest());
+    store.datasets.set('test', adapter);
+    const wrapper = mount(DatasetView, {
+      global: { plugins: [pinia, router] },
+      props: { registerId: 'test' },
+    });
+    await flushPromises();
+    expect(wrapper.text()).toContain('term 1');
+
+    if (action === 'page') {
+      await wrapper.findAll('button').find(b => b.text().includes('Next'))!.trigger('click');
+    } else {
+      await wrapper.find('input[aria-label="Filter concepts"]').setValue('term');
+    }
+    await flushPromises();
+
+    expect(wrapper.text()).toContain(error.message);
+    expect(wrapper.findAll('button').some(b => b.text() === 'Retry')).toBe(true);
+    expect(wrapper.find('.skeleton').exists()).toBe(false);
+    expect((wrapper.vm as unknown as { chunkLoading: boolean }).chunkLoading).toBe(false);
+
+    failing = false;
+    await wrapper.findAll('button').find(b => b.text() === 'Retry')!.trigger('click');
+    await flushPromises();
+    expect(wrapper.text()).not.toContain(error.message);
+    expect(wrapper.text()).toContain(action === 'page' ? 'term 51' : 'term 1');
+    expect(wrapper.find('.skeleton').exists()).toBe(false);
+    expect(action === 'page' ? adapter.ensureChunksForRange : adapter.ensureAllChunksLoaded).toHaveBeenCalledTimes(2);
+    wrapper.unmount();
+  });
+
   it('shows correct page count in pagination', async () => {
     const wrapper = mountDataset(makeConcepts(120));
     await flushPromises();

package/src/__tests__/model-bridge-citation.test.ts

@@ -2,6 +2,26 @@ import { describe, it, expect } from 'vitest';
 import { conceptFromJson, getRelatedSourceId, getRelatedCitation } from '../adapters/model-bridge';
 
 describe('model-bridge — source id mapping', () => {
+  it('preserves concept-level sources alongside localized sources', () => {
+    const source = (id: string, type = 'authoritative') => ({
+      'gl:sourceType': type,
+      'gl:origin': { 'gl:ref': { 'gl:source': 'ISO', 'gl:id': id } },
+    });
+    const concept = conceptFromJson({
+      '@type': 'gl:Concept',
+      'gl:identifier': '1',
+      'gl:source': [source('19165-2:2020'), source('704:2022', 'lineage')],
+      'gl:localizedConcept': { eng: { 'gl:source': [source('1087:2019')] } },
+    });
+
+    expect(concept.sources.map(s => [s.type, s.origin?.ref?.source, s.origin?.ref?.id])).toEqual([
+      ['authoritative', 'ISO', '19165-2:2020'],
+      ['lineage', 'ISO', '704:2022'],
+    ]);
+    expect(concept.localization('eng')!.sources.map(s => s.origin?.ref?.id)).toEqual(['1087:2019']);
+    expect(conceptFromJson({ '@type': 'gl:Concept', 'gl:identifier': '2' }).sources).toEqual([]);
+  });
+
   it('maps gl:id from JSON-LD ConceptSource', () => {
     const doc = {
       '@type': 'gl:Concept',

package/src/__tests__/same-standard-pane.test.ts

@@ -0,0 +1,174 @@
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { DatasetAdapter } from '../adapters/DatasetAdapter';
+import { collectStandardKeys } from '../utils/source-standard';
+import { useSameStandardTerms } from '../composables/use-same-standard-terms';
+import { useVocabularyStore } from '../stores/vocabulary';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { flushPromises, mount } from '@vue/test-utils';
+import { RouterLink } from 'vue-router';
+import SameStandardPane from '../components/SameStandardPane.vue';
+import type { SameStandardTerms } from '../composables/use-same-standard-terms';
+import { createTestRouter, setupPinia } from './test-helpers';
+
+const groups: SameStandardTerms[] = [
+  {
+    key: 'iso-123', label: 'ISO 123:2024', terms: [
+      { conceptId: 'current', designation: 'Current term' },
+      { conceptId: 'other', designation: 'Related term' },
+      { conceptId: 'third', designation: 'Third term' },
+    ],
+  },
+  { key: 'iec-456', label: 'IEC 456:2020', terms: [{ conceptId: 'fourth', designation: 'Fourth term' }] },
+];
+
+describe('SameStandardPane', () => {
+  let pinia: ReturnType<typeof setupPinia>;
+  let router: Awaited<ReturnType<typeof createTestRouter>>;
+
+  beforeEach(async () => {
+    localStorage.clear();
+    pinia = setupPinia();
+    router = await createTestRouter('dataset');
+  });
+
+  afterEach(() => vi.restoreAllMocks());
+
+  function mountPane(paneGroups = groups) {
+    return mount(SameStandardPane, {
+      props: { groups: paneGroups, registerId: 'test-register', conceptId: 'current' },
+      global: { plugins: [pinia, router] },
+    });
+  }
+
+  it('renders peers from generated concept-level sources in a 1200-concept register', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'concept-source-pane-'));
+    let wrapper: ReturnType<typeof mount> | undefined;
+    try {
+      const conceptsDir = join(root, 'source', 'concepts');
+      const configPath = join(root, 'site-config.yml');
+      mkdirSync(conceptsDir, { recursive: true });
+      writeFileSync(configPath, JSON.stringify({
+        id: 'fixture', title: 'Fixture', uri_base: 'https://example.test',
+        datasets: [{ id: 'fixture', local_path: 'source', languages: ['eng'] }],
+      }));
+      for (let id = 1; id <= 1200; id++) {
+        writeFileSync(join(conceptsDir, `${id}.yaml`), JSON.stringify({
+          termid: String(id),
+          _sources: [1, 600, 1100].includes(id)
+            ? [{ type: 'authoritative', origin: { ref: { source: 'ISO', id: '19165-2:2020' } } }]
+            : [],
+          eng: { terms: [{ designation: `Fixture term ${id}` }] },
+        }));
+      }
+      execFileSync(process.execPath, [
+        '--import', resolve('node_modules/tsx/dist/loader.mjs'), resolve('scripts/generate-data.ts'),
+      ], { cwd: root, env: { ...process.env, SITE_CONFIG: configPath }, stdio: 'pipe', timeout: 30_000 });
+      const readJson = (url: string) => JSON.parse(readFileSync(join(root, 'public', url), 'utf8'));
+      expect(readJson('/data/fixture/standards.json')).toEqual({
+        'iso 19165-2:2020': { label: 'ISO 19165-2:2020', conceptIds: ['1', '600', '1100'] },
+      });
+      vi.stubGlobal('fetch', vi.fn(async (url: string) => ({ ok: true, json: async () => readJson(url) })));
+      const adapter = new DatasetAdapter('fixture', '/data/fixture');
+      await adapter.loadIndex();
+      const concept = await adapter.fetchConcept('1');
+      expect(concept.sources).toHaveLength(1);
+      expect(concept.localization('eng')!.sources).toEqual([]);
+      expect(collectStandardKeys(concept)).toEqual(['iso 19165-2:2020']);
+      const store = useVocabularyStore();
+      store.datasets.set('fixture', adapter);
+      store.currentRegisterId = 'fixture';
+      store.currentConcept = concept;
+      wrapper = mount({
+        components: { SameStandardPane },
+        setup: () => ({ groups: useSameStandardTerms('/') }),
+        template: '<SameStandardPane :groups="groups" register-id="fixture" concept-id="1" />',
+      }, { global: { plugins: [pinia, router] } });
+      await vi.waitFor(() => expect(wrapper!.findAll('a').map(link => link.text())).toEqual([
+        'Fixture term 600', 'Fixture term 1100',
+      ]));
+      expect(wrapper.findAll('a').map(link => link.attributes('href'))).toEqual([
+        '/dataset/fixture/concept/600', '/dataset/fixture/concept/1100',
+      ]);
+      expect(wrapper.get('h3').text()).toContain('ISO 19165-2:2020');
+    } finally {
+      wrapper?.unmount();
+      vi.unstubAllGlobals();
+      rmSync(root, { recursive: true, force: true });
+    }
+  }, 60_000);
+
+  it('groups terms with filtered counts and named links in the current register', async () => {
+    const wrapper = mountPane();
+    const sections = wrapper.findAll('section');
+    expect(sections).toHaveLength(2);
+    expect(sections[0].find('h3').text()).toContain('ISO 123:2024');
+    expect(sections[0].find('h3').text()).toContain('(2)');
+    expect(sections[1].find('h3').text()).toContain('IEC 456:2020');
+    expect(sections[1].find('h3').text()).toContain('(1)');
+    expect(wrapper.text()).not.toContain('Current term');
+    const links = wrapper.findAllComponents(RouterLink);
+    expect(links.map(link => link.props('to'))).toEqual([
+      { name: 'concept', params: { registerId: 'test-register', conceptId: 'other' } },
+      { name: 'concept', params: { registerId: 'test-register', conceptId: 'third' } },
+      { name: 'concept', params: { registerId: 'test-register', conceptId: 'fourth' } },
+    ]);
+    expect(wrapper.findAll('a').map(link => link.attributes('href'))).toEqual([
+      '/dataset/test-register/concept/other',
+      '/dataset/test-register/concept/third',
+      '/dataset/test-register/concept/fourth',
+    ]);
+    expect(links[0].text()).toBe('Related term');
+    await links[0].trigger('click');
+    await flushPromises();
+    expect(router.currentRoute.value.params).toEqual({ registerId: 'test-register', conceptId: 'other' });
+  });
+
+  it('renders nothing for missing groups or groups containing only the current concept', () => {
+    expect(mountPane([]).find('aside').exists()).toBe(false);
+    expect(mountPane([{ key: 'empty', label: 'Empty standard', terms: [] }]).find('aside').exists()).toBe(false);
+    expect(mountPane([{ ...groups[0], terms: [groups[0].terms[0]] }]).find('aside').exists()).toBe(false);
+  });
+
+  it('uses a native accessible toggle and persists collapsed state across remounts', async () => {
+    const wrapper = mountPane();
+    const button = wrapper.get('button');
+    expect(button.attributes('type')).toBe('button');
+    expect(button.attributes('aria-expanded')).toBe('true');
+    const target = wrapper.get(`#${button.attributes('aria-controls')}`);
+    expect(target.isVisible()).toBe(true);
+    await button.trigger('click');
+    expect(button.attributes('aria-expanded')).toBe('false');
+    expect(target.isVisible()).toBe(false);
+    wrapper.unmount();
+
+    const remounted = mountPane();
+    expect(remounted.get('button').attributes('aria-expanded')).toBe('false');
+    await remounted.get('button').trigger('click');
+    expect(remounted.get(`#${remounted.get('button').attributes('aria-controls')}`).isVisible()).toBe(true);
+    remounted.unmount();
+    expect(mountPane().get('button').attributes('aria-expanded')).toBe('true');
+  });
+
+  it('gives each pane its own controlled region', () => {
+    const wrapper = mount({
+      components: { SameStandardPane },
+      setup: () => ({ groups }),
+      template: '<div><SameStandardPane :groups="groups" register-id="test" concept-id="current" /><SameStandardPane :groups="groups" register-id="test" concept-id="current" /></div>',
+    }, { global: { plugins: [pinia, router] } });
+    const [first, second] = wrapper.findAll('button').map(button => button.attributes('aria-controls'));
+    expect(first).toBeTruthy();
+    expect(second).not.toBe(first);
+  });
+
+  it('continues toggling when storage reads or writes fail', async () => {
+    vi.spyOn(Storage.prototype, 'getItem').mockImplementation(() => { throw new Error('Unavailable'); });
+    vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => { throw new Error('Unavailable'); });
+    const wrapper = mountPane();
+    expect(wrapper.get('button').attributes('aria-expanded')).toBe('true');
+    await wrapper.get('button').trigger('click');
+    expect(wrapper.get('button').attributes('aria-expanded')).toBe('false');
+  });
+});

package/src/__tests__/scripts/generate-data.test.ts

@@ -0,0 +1,74 @@
+// @vitest-environment node
+import { describe, expect, it } from 'vitest';
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+interface Chunk {
+  file: string;
+  count: number;
+  hash: string;
+}
+
+describe('generate-data chunk hashes', () => {
+  it('writes content hashes to both indexes and changes only the hash of modified chunks', () => {
+    const root = mkdtempSync(join(tmpdir(), 'generate-data-hashes-'));
+    const conceptsDir = join(root, 'source', 'concepts');
+    const outputDir = join(root, 'public', 'data', 'fixture');
+    const configPath = join(root, 'site-config.yml');
+    const generator = resolve('scripts/generate-data.ts');
+    const tsx = resolve('node_modules/tsx/dist/loader.mjs');
+
+    const writeConcept = (id: number, designation: string) => {
+      writeFileSync(join(conceptsDir, `${id}.yaml`), JSON.stringify({
+        termid: String(id),
+        eng: { terms: [{ designation }], entry_status: 'valid' },
+      }));
+    };
+    const generate = () => {
+      execFileSync(process.execPath, ['--import', tsx, generator], {
+        cwd: root,
+        env: { ...process.env, SITE_CONFIG: configPath },
+        stdio: 'pipe',
+        timeout: 30_000,
+      });
+      const indexes = ['index.json', 'index-meta.json'].map(file =>
+        JSON.parse(readFileSync(join(outputDir, file), 'utf8')),
+      );
+      for (const index of indexes) {
+        expect(index.conceptCount).toBe(501);
+        expect(index.chunks.map((chunk: Chunk) => chunk.count)).toEqual([500, 1]);
+        for (const chunk of index.chunks as Chunk[]) {
+          expect(chunk.hash).toMatch(/^[a-f0-9]{12}$/);
+          const content = readFileSync(join(outputDir, 'chunks', chunk.file));
+          expect(chunk.hash).toBe(createHash('sha256').update(content).digest('hex').slice(0, 12));
+        }
+      }
+      expect(indexes[1].chunks).toEqual(indexes[0].chunks);
+      return indexes[0].chunks as Chunk[];
+    };
+
+    try {
+      mkdirSync(conceptsDir, { recursive: true });
+      writeFileSync(configPath, JSON.stringify({
+        id: 'fixture', title: 'Fixture', uri_base: 'https://example.test',
+        datasets: [{ id: 'fixture', local_path: 'source', languages: ['eng'] }],
+      }));
+      for (let id = 1; id <= 501; id++) writeConcept(id, `Term ${id}`);
+
+      const initial = generate();
+      expect(generate()).toEqual(initial);
+
+      writeConcept(1, 'Updated term');
+      const changed = generate();
+      expect(changed[0]!.hash).not.toBe(initial[0]!.hash);
+      expect(changed[1]).toEqual(initial[1]);
+      const chunk = JSON.parse(readFileSync(join(outputDir, 'chunks', changed[0]!.file), 'utf8'));
+      expect(chunk.concepts[0].designations.eng).toBe('Updated term');
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }, 60_000);
+});

package/src/__tests__/search-across-datasets.test.ts

@@ -0,0 +1,102 @@
+import { createPinia, setActivePinia } from 'pinia';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useVocabularyStore } from '../stores/vocabulary';
+import type { DatasetAdapter } from '../adapters/DatasetAdapter';
+import type { Manifest, SearchHit } from '../adapters/types';
+
+const discoverDatasets = vi.fn();
+vi.mock('../adapters/factory', () => ({
+  getFactory: () => ({ discoverDatasets, getAdapters: () => [], loadDataset: vi.fn() }),
+}));
+
+function adapter(registerId: string, indexRows: SearchHit[], laterRows: SearchHit[] = [], options: { failLoad?: boolean; manifest?: boolean } = {}) {
+  const index = { concepts: [...indexRows] };
+  const search = vi.fn((query: string) => index.concepts
+    .filter((row) => row.designation.toLowerCase().includes(query.toLowerCase())));
+  const ensureAllChunksLoaded = vi.fn(async () => {
+    await Promise.resolve();
+    if (options.failLoad) throw new Error('chunk unavailable');
+    index.concepts.push(...laterRows);
+  });
+  return {
+    adapter: {
+      registerId,
+      manifest: options.manifest === false ? null : { id: registerId } as Manifest,
+      index,
+      loadIndex: vi.fn(async () => undefined),
+      search,
+      ensureAllChunksLoaded,
+    } as unknown as DatasetAdapter,
+    search,
+    ensureAllChunksLoaded,
+  };
+}
+
+const hit = (registerId: string, conceptId: string, designation: string, status = 'valid'): SearchHit => ({
+  registerId, conceptId, designation, status, language: 'eng', matchField: 'designation',
+});
+
+describe('searchAcrossDatasets', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+    discoverDatasets.mockReset();
+  });
+
+  it('returns both location concepts on first and repeated searches', async () => {
+    const large = adapter('large', [hit('large', '276', 'location', 'superseded'), hit('large', '999', 'place-name')], [hit('large', '2345', 'location'), hit('large', '1280', 'place')]);
+    const other = adapter('other', [], [hit('other', '1280', 'place')]);
+    discoverDatasets.mockResolvedValue([large.adapter, other.adapter]);
+    const store = useVocabularyStore();
+    const locationHits = await store.searchAcrossDatasets('location');
+    expect(locationHits.map(({ conceptId, status }) => [conceptId, status])).toEqual([['276', 'superseded'], ['2345', 'valid']]);
+    const repeatedLocationHits = await store.searchAcrossDatasets('location');
+    expect(repeatedLocationHits.map(({ conceptId, status }) => [conceptId, status])).toEqual([['276', 'superseded'], ['2345', 'valid']]);
+    expect(large.ensureAllChunksLoaded).toHaveBeenCalledTimes(2);
+
+  });
+
+  it('finds later place concepts even when chunk zero has a matching term', async () => {
+    const freshLarge = adapter('large', [hit('large', '999', 'place-name')], [hit('large', '1280', 'place')]);
+    const freshOther = adapter('other', [], [hit('other', '1280', 'place')]);
+    discoverDatasets.mockResolvedValue([freshLarge.adapter, freshOther.adapter]);
+    const placeHits = await useVocabularyStore().searchAcrossDatasets('place');
+    expect(placeHits.map(({ registerId, conceptId }) => [registerId, conceptId])).toEqual([['large', '999'], ['large', '1280'], ['other', '1280']]);
+  });
+
+  it('preserves loaded hits when a later chunk fails and continues searching other datasets', async () => {
+    const loadedHit = hit('partial', '276', 'location', 'superseded');
+    const partial = adapter('partial', [loadedHit], [], { failLoad: true });
+    const healthyHit = hit('healthy', '2345', 'location');
+    const healthy = adapter('healthy', [], [healthyHit]);
+    discoverDatasets.mockResolvedValue([partial.adapter, healthy.adapter]);
+
+    const store = useVocabularyStore();
+    const results = await store.searchAcrossDatasets('location');
+
+    expect(partial.ensureAllChunksLoaded).toHaveBeenCalledOnce();
+    expect(results).toEqual([loadedHit, healthyHit]);
+    expect(store.searchWarning).toBe('search.incomplete');
+
+    partial.ensureAllChunksLoaded.mockResolvedValue(undefined);
+    await store.searchAcrossDatasets('location');
+    expect(store.searchWarning).toBeNull();
+  });
+
+  it('continues after more than 20 hits and isolates chunk load and search failures', async () => {
+    const crowdedRows = Array.from({ length: 21 }, (_, i) => hit('crowded', `needle-${i}`, 'needle'));
+    const crowded = adapter('crowded', crowdedRows);
+    const late = adapter('late', [], [hit('late', 'late-1', 'needle')]);
+    const brokenLoad = adapter('broken-load', [], [], { failLoad: true });
+    const noManifest = adapter('no-manifest', [], [hit('no-manifest', 'skip', 'needle')], { manifest: false });
+    const brokenSearch = adapter('broken-search', []);
+    brokenSearch.search.mockImplementation(() => { throw new Error('search failed'); });
+    discoverDatasets.mockResolvedValue([crowded.adapter, brokenLoad.adapter, noManifest.adapter, brokenSearch.adapter, late.adapter]);
+
+    const results = await useVocabularyStore().searchAcrossDatasets('needle');
+    expect(results.map(({ registerId, conceptId }) => [registerId, conceptId])).toContainEqual(['late', 'late-1']);
+    expect(results).toHaveLength(22);
+    expect(late.ensureAllChunksLoaded).toHaveBeenCalledOnce();
+    expect(brokenLoad.ensureAllChunksLoaded).toHaveBeenCalledOnce();
+    expect(noManifest.ensureAllChunksLoaded).not.toHaveBeenCalled();
+  });
+});