@glossarist/concept-browser 0.7.139 → 0.7.141

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

@@ -1,8 +1,11 @@
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { mount, flushPromises } from '@vue/test-utils';
+import { createRouter, createMemoryHistory, RouterView } from 'vue-router';
 import SearchView from '../views/SearchView.vue';
+import { DatasetAdapter } from '../adapters/DatasetAdapter';
 import { useVocabularyStore } from '../stores/vocabulary';
-import { createTestRouter, setupPinia, makeManifest, makeAdapterStub } from './test-helpers';
+import { useUiStore } from '../stores/ui';
+import { createTestRouter, setupPinia, makeManifest, makeAdapterStub, makeSearchHit } from './test-helpers';
 
 describe('SearchView', () => {
   let pinia: ReturnType<typeof setupPinia>;
@@ -12,22 +15,119 @@ describe('SearchView', () => {
     pinia = setupPinia();
     router = await createTestRouter('search', '/search');
     const store = useVocabularyStore();
+    store.initialized = true;
     store.manifests.set('test', makeManifest());
     store.datasets.set('test', makeAdapterStub());
   });
 
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
   function mountView() {
     return mount(SearchView, {
       global: { plugins: [pinia, router], stubs: { SearchBar: true } },
     });
   }
 
+  async function mountRoutedSearch(path = '/search') {
+    router = createRouter({
+      history: createMemoryHistory(),
+      routes: [
+        { path: '/', name: 'home', component: { template: '<div>Home page</div>' } },
+        { path: '/search', name: 'search', component: SearchView },
+      ],
+    });
+    await router.push(path);
+    await router.isReady();
+    const wrapper = mount({ components: { RouterView }, template: '<RouterView />' }, {
+      global: { plugins: [pinia, router] },
+    });
+    await flushPromises();
+    return wrapper;
+  }
+
   it('renders breadcrumb navigation', () => {
     const wrapper = mountView();
     expect(wrapper.text()).toContain('Home');
     expect(wrapper.text()).toContain('Search');
   });
 
+  it.each(['transient', 'persistent'] as const)('warns about a %s chunk failure and retries from the routed search', async (failure) => {
+    const manifest = makeManifest({ conceptCount: 2001 });
+    const adapter = new DatasetAdapter('test', '/data/test');
+    adapter.manifest = manifest;
+    const store = useVocabularyStore();
+    store.manifests.set('test', manifest);
+    store.datasets.set('test', adapter);
+
+    const chunks = [
+      Array.from({ length: 1000 }, (_, i) => ({
+        id: i === 0 ? '276' : `first-${i}`,
+        designations: { eng: i === 0 ? 'location' : `unrelated first ${i}` },
+        status: i === 0 ? 'superseded' : 'valid',
+      })),
+      Array.from({ length: 1000 }, (_, i) => ({
+        id: i === 0 ? '2345' : `second-${i}`,
+        designations: { eng: i === 0 ? 'location' : `unrelated second ${i}` },
+        status: 'valid',
+      })),
+      [{ id: '9999', designations: { eng: 'unrelated last entry' }, status: 'valid' }],
+    ];
+    let failedChunkRequests = 0;
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url === '/data/test/index-meta.json') {
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({
+            registerId: 'test', schemaVersion: '1.0.0', conceptCount: 2001, chunkSize: 1000,
+            chunks: chunks.map((concepts, i) => ({ file: `index-${i}.json`, count: concepts.length })),
+          }),
+        } as Response;
+      }
+      const chunkIndex = chunks.findIndex((_, i) => url === `/data/test/chunks/index-${i}.json`);
+      if (chunkIndex < 0) throw new Error(`Unexpected fetch: ${url}`);
+      if (chunkIndex === 1 && (++failedChunkRequests === 1 || failure === 'persistent')) {
+        return { ok: false, status: 404 } as Response;
+      }
+      return { ok: true, status: 200, json: async () => ({ concepts: chunks[chunkIndex] }) } as Response;
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const wrapper = await mountRoutedSearch('/search?q=location');
+    try {
+      expect((wrapper.find('input').element as HTMLInputElement).value).toBe('location');
+      expect(wrapper.get('[role="alert"]').text()).toContain('Some results could not be loaded');
+      expect(wrapper.get('.search-results').text()).toContain('276');
+      expect(wrapper.get('.search-results').text()).toContain('superseded');
+      expect(wrapper.get('.search-results').text()).not.toContain('2345');
+      expect(wrapper.get('.search-results').text()).not.toContain('9999');
+
+      const retry = wrapper.findAll('button').find(button => button.text() === 'Retry');
+      expect(retry).toBeDefined();
+      await retry!.trigger('click');
+      await flushPromises();
+
+      expect(failedChunkRequests).toBe(2);
+      expect(router.currentRoute.value.fullPath).toBe('/search?q=location');
+      expect(wrapper.get('.search-results').text()).toContain('276');
+      expect(wrapper.get('.search-results').text()).not.toContain('9999');
+      if (failure === 'transient') {
+        expect(wrapper.get('.search-results').text()).toContain('2345');
+        expect(wrapper.find('[role="alert"]').exists()).toBe(false);
+      } else {
+        expect(wrapper.get('.search-results').text()).not.toContain('2345');
+        expect(wrapper.get('[role="alert"]').text()).toContain('Some results could not be loaded');
+      }
+      expect(fetchMock.mock.calls.filter(([url]) => url === '/data/test/chunks/index-0.json')).toHaveLength(1);
+      expect(fetchMock.mock.calls.filter(([url]) => url === '/data/test/chunks/index-2.json')).toHaveLength(1);
+    } finally {
+      wrapper.unmount();
+    }
+  });
+
   it('renders SearchBar component', () => {
     const wrapper = mountView();
     expect(wrapper.findComponent({ name: 'SearchBar' }).exists()).toBe(true);
@@ -38,4 +138,96 @@ describe('SearchView', () => {
     const homeLink = wrapper.findAll('a').find(a => a.text() === 'Home');
     expect(homeLink).toBeDefined();
   });
+
+  it('searches an initial query parameter and restores it when returning to search', async () => {
+    const store = useVocabularyStore();
+    const search = vi.fn(() => [makeSearchHit({ designation: 'Foo result' })]);
+    store.datasets.set('test', makeAdapterStub({ search }));
+    const wrapper = await mountRoutedSearch('/search?q=foo');
+    const ui = useUiStore();
+    await flushPromises();
+
+    expect(search).toHaveBeenCalledWith('foo');
+    expect(search).toHaveBeenCalledTimes(1);
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('foo');
+    expect(wrapper.text()).toContain('Foo result');
+
+    await router.push('/');
+    await flushPromises();
+    expect(wrapper.text()).toContain('Home page');
+    expect(ui.searchQuery).toBe('');
+
+    await router.push('/search');
+    await flushPromises();
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('');
+    expect(ui.searchQuery).toBe('');
+    expect(wrapper.text()).not.toContain('Foo result');
+    expect(wrapper.find('.search-results').exists()).toBe(false);
+    expect(search).toHaveBeenCalledTimes(1);
+
+    await router.push('/');
+    await flushPromises();
+    await router.push('/search?q=bar');
+    await flushPromises();
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('bar');
+    expect(search).toHaveBeenLastCalledWith('bar');
+    wrapper.unmount();
+  });
+
+  it('ignores a leftover store query when mounting without a query parameter', async () => {
+    const ui = useUiStore();
+    ui.searchQuery = 'stale';
+    const search = vi.spyOn(useVocabularyStore(), 'searchAcrossDatasets');
+    const wrapper = await mountRoutedSearch('/search');
+
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('');
+    expect(ui.searchQuery).toBe('');
+    expect(search).not.toHaveBeenCalled();
+    expect(wrapper.find('.search-results').exists()).toBe(false);
+    wrapper.unmount();
+  });
+
+  it('clears the search when the query parameter is removed while mounted', async () => {
+    const store = useVocabularyStore();
+    const search = vi.fn(() => [makeSearchHit({ designation: 'Foo result' })]);
+    store.datasets.set('test', makeAdapterStub({ search }));
+    const wrapper = await mountRoutedSearch('/search?q=foo');
+    const ui = useUiStore();
+    await flushPromises();
+    expect(wrapper.text()).toContain('Foo result');
+
+    await router.replace('/search?q=bar');
+    await flushPromises();
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('bar');
+    expect(search).toHaveBeenLastCalledWith('bar');
+
+    await router.replace('/search');
+    await flushPromises();
+
+    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('');
+    expect(ui.searchQuery).toBe('');
+    expect(wrapper.text()).not.toContain('Foo result');
+    expect(wrapper.find('.search-results').exists()).toBe(false);
+    wrapper.unmount();
+  });
+
+  it('does not let a pending search restore the URL after leaving search', async () => {
+    const store = useVocabularyStore();
+    let resolveSearch!: (hits: ReturnType<typeof makeSearchHit>[]) => void;
+    const search = vi.spyOn(store, 'searchAcrossDatasets').mockImplementation(() => new Promise(resolve => {
+      resolveSearch = resolve;
+    }));
+    const wrapper = await mountRoutedSearch('/search?q=foo');
+    await flushPromises();
+    expect(search).toHaveBeenCalledWith('foo');
+
+    await router.push('/');
+    resolveSearch([makeSearchHit({ designation: 'Late result' })]);
+    await flushPromises();
+
+    expect(router.currentRoute.value.fullPath).toBe('/');
+    expect(wrapper.text()).toContain('Home page');
+    expect(wrapper.text()).not.toContain('Late result');
+    wrapper.unmount();
+  });
 });

package/src/__tests__/source-standard.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+import { Citation, Concept } from 'glossarist';
+import { collectStandardKeys, standardKey, standardLabel } from '../utils/source-standard';
+
+describe('standard references', () => {
+  it.each([
+    [{ source: 'ISO', id: '19165-2:2020' }, 'iso 19165-2:2020', 'ISO 19165-2:2020'],
+    [{ id: '19165-2:2020' }, '19165-2:2020', '19165-2:2020'],
+    [{ source: 'ISO 19165-2:2020' }, 'iso 19165-2:2020', 'ISO 19165-2:2020'],
+    [{ source: '  ISO\t IEC ', id: '  17000:2020\n' }, 'iso iec 17000:2020', 'ISO IEC 17000:2020'],
+    [{ source: ' ', id: '19165-2:2020' }, '19165-2:2020', '19165-2:2020'],
+  ])('combines usable source and id: %j', (ref, key, label) => {
+    expect(standardKey(ref)).toBe(key);
+    expect(standardLabel(ref)).toBe(label);
+  });
+
+  it.each([undefined, null, {}, { source: ' \t', id: '\n' }])('returns null for unusable ref %j', (ref) => {
+    expect(standardKey(ref)).toBeNull();
+    expect(standardLabel(ref)).toBeNull();
+  });
+
+  it('ignores clauses and localities without changing the input', () => {
+    const ref = Object.freeze({ source: 'ISO', id: '19165-2:2020', clause: '3.1', locality: '3.1' });
+    const otherClause = { ...ref, clause: '4.2', locality: '4.2' };
+    expect(standardKey(ref)).toBe('iso 19165-2:2020');
+    expect(standardKey(otherClause)).toBe(standardKey(ref));
+    expect(standardLabel(ref)).toBe('ISO 19165-2:2020');
+  });
+
+  it('distinguishes standards and editions but ignores case', () => {
+    const ref = { source: 'ISO', id: '19165-2:2020' };
+    expect(standardKey({ ...ref, source: 'iso' })).toBe(standardKey(ref));
+    expect(standardKey({ ...ref, id: '19165-2:2024' })).not.toBe(standardKey(ref));
+    expect(standardKey({ ...ref, id: '19115:2020' })).not.toBe(standardKey(ref));
+  });
+});
+
+describe('collectStandardKeys', () => {
+  it('collects unique authoritative references across the concept and all languages', () => {
+    const source = (id: string, type = 'authoritative') => ({ type, origin: { ref: { source: 'ISO', id } } });
+    const concept = Concept.fromJSON({
+      id: '1',
+      sources: [source('19165-2:2020'), source('704:2022', 'lineage'), { type: 'authoritative' }],
+      localizations: {
+        eng: { sources: [source('19165-2:2020'), source('19165-2:2024')] },
+        fra: { sources: [source('1087:2019'), source('999:2020', 'lineage'), source('998:2020', '')] },
+      },
+    });
+    expect(collectStandardKeys(concept)).toEqual(['iso 19165-2:2020', 'iso 19165-2:2024', 'iso 1087:2019']);
+  });
+
+  it('returns no keys for a concept without sources', () => {
+    expect(collectStandardKeys(Concept.fromJSON({ id: '1' }))).toEqual([]);
+  });
+
+  it('deduplicates citations of different clauses of the same standard', () => {
+    const concept = Concept.fromJSON({
+      id: '1',
+      sources: ['3.1', '4.2'].map(clause => ({
+        type: 'authoritative',
+        origin: Citation.fromJSON({
+          ref: { source: 'ISO', id: '19165-2:2020' },
+          locality: { type: 'clause', reference_from: clause },
+        }),
+      })),
+    });
+    expect(concept.sources[0].origin?.locality).not.toEqual(concept.sources[1].origin?.locality);
+    expect(collectStandardKeys(concept)).toEqual(['iso 19165-2:2020']);
+  });
+});

package/src/__tests__/ui-store.test.ts

@@ -97,4 +97,30 @@ describe('useUiStore', () => {
     ui.setTheme('light');
     expect(ui.isDark).toBe(false);
   });
+
+  it('defaults searchSort to language', () => {
+    const ui = useUiStore();
+    expect(ui.searchSort).toBe('language');
+  });
+
+  it('setSearchSort updates value and localStorage', () => {
+    const ui = useUiStore();
+    ui.setSearchSort('relevance');
+    expect(ui.searchSort).toBe('relevance');
+    expect(localStorage.getItem('searchSort')).toBe('relevance');
+  });
+
+  it('reads stored searchSort from localStorage', () => {
+    localStorage.setItem('searchSort', 'relevance');
+    setActivePinia(createPinia());
+    const ui = useUiStore();
+    expect(ui.searchSort).toBe('relevance');
+  });
+
+  it('falls back to language for a junk stored searchSort', () => {
+    localStorage.setItem('searchSort', 'bogus');
+    setActivePinia(createPinia());
+    const ui = useUiStore();
+    expect(ui.searchSort).toBe('language');
+  });
 });

package/src/__tests__/vocabulary-layered.test.ts

@@ -178,7 +178,7 @@ describe('vocabulary store — layered loading', () => {
   });
 
   describe('searchAcrossDatasets — two-pass', () => {
-    it('returns results from loaded data without loading chunks', async () => {
+    it('loads every chunk even when the index already has 20 or more hits', async () => {
       const store = useVocabularyStore();
       store.initialized = true;
 
@@ -207,11 +207,11 @@ describe('vocabulary store — layered loading', () => {
       const results = await store.searchAcrossDatasets('concept');
 
       expect(results.length).toBe(25);
-      // With ≥20 results, chunks should NOT be loaded
-      expect(chunksLoaded).toBe(false);
+      // Load every chunk even when the index already has at least 20 hits.
+      expect(chunksLoaded).toBe(true);
     });
 
-    it('loads chunks for adapters with zero index hits when total is under threshold', async () => {
+    it('loads every dataset regardless of whether its index has hits', async () => {
       const store = useVocabularyStore();
       store.initialized = true;
 
@@ -258,9 +258,9 @@ describe('vocabulary store — layered loading', () => {
       const results = await store.searchAcrossDatasets('item');
 
       expect(results.length).toBe(6); // 5 from ds1 index + 1 from ds2 chunks
-      // Adapter 1 should NOT have loaded chunks (it had index hits)
-      expect(adapter1ChunksLoaded).toBe(false);
-      // Adapter 2 should have loaded chunks (it had 0 index hits, total < 20)
+      // Adapter 1 loads every chunk even though its index already had hits.
+      expect(adapter1ChunksLoaded).toBe(true);
+      // Adapter 2 also loads every chunk, exposing its hidden hit.
       expect(adapter2ChunksLoaded).toBe(true);
     });
 

package/src/adapters/DatasetAdapter.ts

@@ -26,7 +26,7 @@ interface IndexJson {
   schemaVersion: string;
   conceptCount: number;
   chunkSize: number;
-  chunks: { file: string; count: number }[];
+  chunks: { file: string; count: number; hash?: string }[];
   concepts: IndexConceptJson[];
 }
 
@@ -52,7 +52,7 @@ export class DatasetAdapter {
   private summaryMap = new Map<string, ConceptSummary>();
   private designationMap = new Map<string, string>();
   private loadedChunks = new Set<number>();
-  private indexMeta: { conceptCount: number; chunkSize: number; chunks: { file: string; count: number }[] } | null = null;
+  private indexMeta: Pick<IndexJson, 'conceptCount' | 'chunkSize' | 'chunks'> | null = null;
 
   constructor(registerId: string, baseUrl: string) {
     this.registerId = registerId;
@@ -152,7 +152,7 @@ export class DatasetAdapter {
 
   private async loadIndexChunked(): Promise<ConceptIndex> {
     const metaResp = await fetch(`${this.baseUrl}/index-meta.json`);
-    let meta: { registerId: string; schemaVersion: string; conceptCount: number; chunkSize: number; chunks: { file: string; count: number }[] };
+    let meta: Omit<IndexJson, 'concepts'>;
     if (metaResp.ok) {
       meta = await metaResp.json();
     } else {
@@ -183,10 +183,17 @@ export class DatasetAdapter {
     return this.index;
   }
 
+  private chunkUrl(chunkIndex: number): string {
+    const chunks: IndexJson['chunks'] = this.indexMeta?.chunks ?? this.index?.chunks ?? [];
+    const chunk = chunks[chunkIndex];
+    const file = chunk?.file ?? `index-${String(chunkIndex).padStart(4, '0')}.json`;
+    const query = chunk?.hash ? `?v=${encodeURIComponent(chunk.hash)}` : '';
+    return `${this.baseUrl}/chunks/${file}${query}`;
+  }
+
   async loadChunk(chunkIndex: number): Promise<ConceptEntry[]> {
     if (this.loadedChunks.has(chunkIndex)) return [];
-    const chunkFile = `index-${String(chunkIndex).padStart(4, '0')}.json`;
-    const resp = await fetch(`${this.baseUrl}/chunks/${chunkFile}`);
+    const resp = await fetch(this.chunkUrl(chunkIndex));
     if (!resp.ok) throw ChunkLoadError.make(this.registerId, chunkIndex, resp.status);
     const data = await resp.json();
     this.loadedChunks.add(chunkIndex);
@@ -196,9 +203,8 @@ export class DatasetAdapter {
   private async loadChunkAsSummaries(chunkIndex: number): Promise<void> {
     if (this.loadedChunks.has(chunkIndex)) return;
 
-    const chunkFile = `index-${String(chunkIndex).padStart(4, '0')}.json`;
-    const resp = await fetch(`${this.baseUrl}/chunks/${chunkFile}`);
-    if (!resp.ok) return;
+    const resp = await fetch(this.chunkUrl(chunkIndex));
+    if (!resp.ok) throw ChunkLoadError.make(this.registerId, chunkIndex, resp.status);
     const data = await resp.json();
     this.loadedChunks.add(chunkIndex);
 
@@ -329,6 +335,7 @@ export class DatasetAdapter {
           conceptId: entry.id,
           registerId: this.registerId,
           designation: entry.eng || '',
+          status: entry.status,
           language: '',
           matchField: 'id',
           snippet: `ID: ${entry.id}`,
@@ -347,6 +354,7 @@ export class DatasetAdapter {
             conceptId: entry.id,
             registerId: this.registerId,
             designation: term,
+            status: entry.status,
             language,
             matchField: 'designation',
             _score: score,

package/src/adapters/jsonld-types.ts

@@ -166,6 +166,7 @@ export interface JsonLdConcept {
   'gl:identifier'?: string | number;
   'gl:term'?: string;
   'gl:localizedConcept'?: Record<string, JsonLdLocalizedConcept>;
+  'gl:source'?: JsonLdSource[];
   'gl:related'?: JsonLdRelated[];
   'gl:partitiveRelations'?: JsonLdPartitiveRelation[];
   'gl:genericRelations'?: JsonLdPartitiveRelation[];

package/src/adapters/model-bridge.ts

@@ -623,6 +623,7 @@ function conceptFromJsonLd(doc: JsonLdConcept): Concept {
     term: doc[GL.TERM] ?? null,
     uri: doc['@id'] ?? null,
     localizations: localizations as Record<string, any>,
+    sources: (doc[GL.SOURCE] ?? []).map(mapSourceFromJsonLd),
     related,
     partitive_relations: partitiveRelations,
     generic_relations: genericRelations,

package/src/adapters/standards-index.ts

@@ -0,0 +1,7 @@
+/** Per-register standards.json, keyed by the normalized cited-standard identity. */
+export type StandardsIndex = Record<string, {
+  /** Normalized display label from the first authoritative citation encountered. */
+  label: string;
+  /** Unique concept IDs in dataset encounter order. */
+  conceptIds: string[];
+}>;

package/src/adapters/types.ts

@@ -238,6 +238,7 @@ export interface SectionNode {
 export interface SearchHit {
   conceptId: string;
   registerId: string;
+  status?: string;
   designation: string;
   language: string;
   matchField: 'designation' | 'id';

package/src/components/AppFooter.vue

@@ -26,6 +26,7 @@ const footerNav = computed(() => config.value?.footerNav ?? []);
 const copyrightOwner = computed(() => config.value?.copyright || '');
 const ownerName = computed(() => config.value?.branding?.ownerName || config.value?.title || '');
 const ownerUrl = computed(() => config.value?.branding?.ownerUrl || '/');
+const hostedBy = computed(() => config.value?.branding?.hostedBy as { name?: string; url: string; logo: string } | undefined);
 </script>
 
 <template>
@@ -58,6 +59,12 @@ const ownerUrl = computed(() => config.value?.branding?.ownerUrl || '/');
             class="hover:text-ink-700 transition-colors"
           >{{ link.label }}</a>
           <span class="text-ink-200">|</span>
+          <span v-if="hostedBy" class="text-xs inline-flex items-center gap-1.5">
+            <span>Hosted by</span>
+            <a :href="hostedBy.url" target="_blank" rel="noopener" class="inline-flex items-center">
+              <img :src="hostedBy.logo" :alt="hostedBy.name || 'Host'" class="h-4 w-auto opacity-80" />
+            </a>
+          </span>
           <span class="text-xs inline-flex items-center gap-1.5">
             <img :src="glossaristLogo" alt="Glossarist" class="w-4 h-4 opacity-80" />
             <a :href="poweredBy.url" target="_blank" rel="noopener" class="concept-link">{{ poweredBy.message }}</a>

package/src/components/AppHeader.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { useRouter } from 'vue-router';
+import { useRoute, useRouter } from 'vue-router';
 import { useUiStore } from '../stores/ui';
 import { useVocabularyStore } from '../stores/vocabulary';
 import { useSiteConfig } from '../config/use-site-config';
@@ -9,6 +9,7 @@ import { ref, computed, onMounted, onBeforeUnmount } from 'vue';
 const glossaristLogo = new URL('../assets/glossarist-logo.svg', import.meta.url).href;
 
 const router = useRouter();
+const route = useRoute();
 const ui = useUiStore();
 const store = useVocabularyStore();
 const { config: siteConfig, localizedTitle } = useSiteConfig();
@@ -26,8 +27,8 @@ const currentLangLabel = computed(() => {
 function doSearch() {
   const q = searchInput.value.trim();
   if (q) {
-    ui.searchQuery = q;
     router.push({ name: 'search', query: { q } });
+    searchInput.value = '';
   }
 }
 
@@ -85,13 +86,13 @@ onBeforeUnmount(() => document.removeEventListener('click', closeLangOnOutside))
       </button>
 
       <!-- Search -->
-      <form @submit.prevent="doSearch" class="flex-1 max-w-lg mx-2 sm:mx-4">
+      <form v-if="route.name !== 'search'" @submit.prevent="doSearch" class="flex-1 max-w-lg mx-2 sm:mx-4">
         <div class="relative">
           <input
             v-model="searchInput"
             type="text"
-            :aria-label="t('search.conceptSearch')"
-            :placeholder="t('search.placeholder')"
+            :aria-label="t('search.quickSearch')"
+            :placeholder="t('search.quickPlaceholder')"
             class="w-full pl-9 pr-3 py-2 text-sm bg-surface border border-ink-100 rounded-lg focus:ring-2 focus:ring-ink-200 focus:border-ink-400 outline-none placeholder:text-ink-300 transition-all"
           />
           <svg class="absolute left-3 top-2.5 w-4 h-4 text-ink-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">

package/src/components/SameStandardPane.vue

@@ -0,0 +1,70 @@
+<script setup lang="ts">
+import { computed, ref, useId } from 'vue';
+import { RouterLink } from 'vue-router';
+import type { SameStandardTerms } from '../composables/use-same-standard-terms';
+import { useI18n } from '../i18n';
+
+const props = defineProps<{
+  groups: SameStandardTerms[];
+  registerId: string;
+  conceptId: string;
+}>();
+
+const { t } = useI18n();
+const contentId = `same-standard-terms-${useId()}`;
+const storageKey = 'same-standard-pane-collapsed';
+const visibleGroups = computed(() => props.groups
+  .map(group => ({ ...group, terms: group.terms.filter(term => term.conceptId !== props.conceptId) }))
+  .filter(group => group.terms.length > 0));
+
+function readCollapsed(): boolean {
+  try {
+    return localStorage.getItem(storageKey) === 'true';
+  } catch {
+    return false;
+  }
+}
+
+const collapsed = ref(readCollapsed());
+
+function toggle() {
+  collapsed.value = !collapsed.value;
+  try {
+    localStorage.setItem(storageKey, String(collapsed.value));
+  } catch {
+    // Browsing remains available when storage is disabled or full.
+  }
+}
+</script>
+
+<template>
+  <aside v-if="visibleGroups.length" class="same-standard-pane rounded-lg border border-gray-200 dark:border-gray-700">
+    <h2>
+      <button
+        type="button"
+        class="flex w-full items-center justify-between gap-3 p-4 text-left text-sm font-semibold text-gray-800 dark:text-gray-200"
+        :aria-expanded="!collapsed"
+        :aria-controls="contentId"
+        @click="toggle"
+      >
+        {{ t('concept.sameStandardTerms') }}
+        <span aria-hidden="true">{{ collapsed ? '+' : '−' }}</span>
+      </button>
+    </h2>
+    <div :id="contentId" :hidden="collapsed" class="space-y-4 border-t border-gray-200 p-4 dark:border-gray-700">
+      <section v-for="group in visibleGroups" :key="group.key">
+        <h3 class="mb-2 text-sm font-medium text-gray-700 dark:text-gray-300">
+          {{ group.label }} <span class="text-gray-500">({{ group.terms.length }})</span>
+        </h3>
+        <ul class="space-y-2 text-sm">
+          <li v-for="term in group.terms" :key="term.conceptId">
+            <RouterLink
+              :to="{ name: 'concept', params: { registerId, conceptId: term.conceptId } }"
+              class="break-words text-blue-600 hover:underline dark:text-blue-400"
+            >{{ term.designation }}</RouterLink>
+          </li>
+        </ul>
+      </section>
+    </div>
+  </aside>
+</template>