@glossarist/concept-browser 0.7.22 → 0.7.24

package/src/__tests__/ontology-registry.test.ts

@@ -8,7 +8,7 @@ describe('OntologyRegistry', () => {
     expect(ontology.getAll('normativeStatus').length).toBe(4);
     expect(ontology.getAll('sourceType').length).toBe(2);
     expect(ontology.getAll('sourceStatus').length).toBe(10);
-    expect(ontology.getAll('relationshipType').length).toBe(51);
+    expect(ontology.getAll('relationshipType').length).toBe(52);
     expect(ontology.getAll('designationType').length).toBe(5);
     expect(ontology.getAll('termType').length).toBe(24);
     expect(ontology.getAll('grammarGender').length).toBe(4);
@@ -100,9 +100,9 @@ describe('OntologyRegistry', () => {
     expect(types).toContain('false_friend');
     expect(types).toContain('abbreviated_form_for');
     expect(types).toContain('short_form_for');
-    expect(types).toContain('sequentially_related_concept');
-    expect(types).toContain('spatially_related_concept');
-    expect(types).toContain('temporally_related_concept');
+    expect(types).toContain('sequentially_related');
+    expect(types).toContain('spatially_related');
+    expect(types).toContain('temporally_related');
     expect(types).toContain('related_concept_broader');
     expect(types).toContain('related_concept_narrower');
   });

package/src/__tests__/performance-v2.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest';
+import { GraphEngine } from '../graph/GraphEngine';
+import type { GraphNode, GraphEdge } from '../adapters/types';
+
+function makeNode(uri: string, conceptId: string, register = 'test'): GraphNode {
+  return { uri, register, conceptId, designations: { eng: conceptId }, status: 'valid', loaded: true };
+}
+
+function makeEdge(source: string, target: string, type = 'references', register = 'test'): GraphEdge {
+  return { source, target, type, register };
+}
+
+describe('GraphEngine encapsulation', () => {
+  it('getEdges() returns a copy, not internal reference', () => {
+    const engine = new GraphEngine();
+    engine.addNode(makeNode('uri:a', 'a'));
+    engine.addNode(makeNode('uri:b', 'b'));
+    engine.addEdge(makeEdge('uri:a', 'uri:b'));
+
+    const edges = engine.getEdges();
+    expect(edges).toHaveLength(1);
+    expect(edges).not.toBe((engine as any).edges);
+  });
+
+  it('mutating getEdges() result does not affect engine', () => {
+    const engine = new GraphEngine();
+    engine.addNode(makeNode('uri:a', 'a'));
+    engine.addNode(makeNode('uri:b', 'b'));
+    engine.addEdge(makeEdge('uri:a', 'uri:b'));
+
+    const edges = engine.getEdges();
+    edges.push(makeEdge('uri:a', 'uri:c'));
+
+    expect(engine.edgeCount).toBe(1);
+  });
+
+  it('getEdges(uri) returns flat array from adjacency', () => {
+    const engine = new GraphEngine();
+    engine.addNode(makeNode('uri:a', 'a'));
+    engine.addNode(makeNode('uri:b', 'b'));
+    engine.addNode(makeNode('uri:c', 'c'));
+    engine.addEdge(makeEdge('uri:a', 'uri:b', 'references'));
+    engine.addEdge(makeEdge('uri:a', 'uri:c', 'supersedes'));
+
+    const edges = engine.getEdges('uri:a');
+    expect(edges).toHaveLength(2);
+    expect(edges.map(e => e.target)).toEqual(expect.arrayContaining(['uri:b', 'uri:c']));
+  });
+
+  it('getIncomingEdges() returns flat array from reverse adjacency', () => {
+    const engine = new GraphEngine();
+    engine.addNode(makeNode('uri:a', 'a'));
+    engine.addNode(makeNode('uri:b', 'b'));
+    engine.addNode(makeNode('uri:c', 'c'));
+    engine.addEdge(makeEdge('uri:a', 'uri:c'));
+    engine.addEdge(makeEdge('uri:b', 'uri:c'));
+
+    const incoming = engine.getIncomingEdges('uri:c');
+    expect(incoming).toHaveLength(2);
+    expect(incoming.map(e => e.source)).toEqual(expect.arrayContaining(['uri:a', 'uri:b']));
+  });
+});
+
+describe('v-math directive optimization', () => {
+  it('querySelector used for early exit check', () => {
+    // Verify the directive code uses querySelector (not querySelectorAll) for the existence check
+    const fs = require('fs');
+    const path = require('path');
+    const code = fs.readFileSync(path.join(__dirname, '../directives/v-math.ts'), 'utf-8');
+
+    // The early exit should use querySelector (returns first match or null)
+    // not querySelectorAll (creates NodeList)
+    expect(code).toContain("querySelector('.math-pending')");
+    // querySelectorAll should only be called after the early exit confirms math exists
+    expect(code).toContain('querySelectorAll');
+  });
+});

package/src/__tests__/performance.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from 'vitest';
+import { GraphEngine } from '../graph/GraphEngine';
+import type { GraphNode, GraphEdge } from '../adapters/types';
+import { setupPinia } from './test-helpers';
+import { useVocabularyStore } from '../stores/vocabulary';
+import { getFactory, resetFactory } from '../adapters/factory';
+import { ref, shallowRef, isReactive, isRef, toRaw } from 'vue';
+
+function makeNode(uri: string, conceptId: string, register = 'test'): GraphNode {
+  return { uri, register, conceptId, designations: { eng: conceptId }, status: 'valid', loaded: true };
+}
+
+function makeEdge(source: string, target: string, type = 'references', register = 'test'): GraphEdge {
+  return { source, target, type, register };
+}
+
+describe('shallowRef graph — no deep proxy', () => {
+  it('graph is shallowRef not deep ref', () => {
+    setupPinia();
+    resetFactory();
+    const store = useVocabularyStore();
+    const raw = toRaw(store.graph);
+    expect(raw).toBeInstanceOf(GraphEngine);
+    expect(raw.nodeCount).toBe(0);
+  });
+
+  it('graph mutations work through shallowRef', () => {
+    setupPinia();
+    resetFactory();
+    const store = useVocabularyStore();
+    const engine = store.graph;
+    engine.addNode(makeNode('uri:a', 'a'));
+    engine.addEdge(makeEdge('uri:a', 'uri:b'));
+    expect(engine.nodeCount).toBe(2);
+    expect(engine.edgeCount).toBe(1);
+  });
+});
+
+describe('LRU conceptCache', () => {
+  it('cache evicts oldest entries beyond MAX_CACHE', () => {
+    // This tests the LRU behavior indirectly through the adapter
+    // The MAX_CACHE is 100, but we verify the mechanism works
+    const cache = new Map<string, string>();
+    const MAX = 5;
+
+    function set(key: string, value: string) {
+      cache.set(key, value);
+      if (cache.size > MAX) {
+        const oldest = cache.keys().next().value;
+        if (oldest !== undefined) cache.delete(oldest);
+      }
+    }
+
+    set('a', '1');
+    set('b', '2');
+    set('c', '3');
+    set('d', '4');
+    set('e', '5');
+    expect(cache.size).toBe(5);
+
+    set('f', '6');
+    expect(cache.size).toBe(5);
+    expect(cache.has('a')).toBe(false);
+    expect(cache.get('f')).toBe('6');
+  });
+
+  it('cache promotes accessed entries', () => {
+    const cache = new Map<string, string>();
+    const MAX = 3;
+
+    function set(key: string, value: string) {
+      // Promote: delete and re-add to move to end
+      cache.delete(key);
+      cache.set(key, value);
+      if (cache.size > MAX) {
+        const oldest = cache.keys().next().value;
+        if (oldest !== undefined) cache.delete(oldest);
+      }
+    }
+
+    set('a', '1');
+    set('b', '2');
+    set('c', '3');
+
+    // Access 'a' to promote it
+    set('a', '1');
+
+    // Add new entry — 'b' should be evicted, not 'a'
+    set('d', '4');
+    expect(cache.has('a')).toBe(true);
+    expect(cache.has('b')).toBe(false);
+    expect(cache.has('c')).toBe(true);
+    expect(cache.has('d')).toBe(true);
+  });
+});

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

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { deduplicateSearchHits } from '../utils/search';
+import type { SearchHit } from '../adapters/types';
+
+function makeHit(overrides: Partial<SearchHit> = {}): SearchHit {
+  return {
+    conceptId: '1',
+    registerId: 'test',
+    designation: 'test',
+    language: 'eng',
+    matchField: 'designation',
+    ...overrides,
+  };
+}
+
+describe('deduplicateSearchHits', () => {
+  it('returns empty array for empty input', () => {
+    expect(deduplicateSearchHits([])).toEqual([]);
+  });
+
+  it('returns single hit unchanged', () => {
+    const hit = makeHit();
+    expect(deduplicateSearchHits([hit])).toEqual([hit]);
+  });
+
+  it('deduplicates by registerId:conceptId', () => {
+    const hit1 = makeHit({ registerId: 'viml', conceptId: '1', designation: 'accuracy' });
+    const hit2 = makeHit({ registerId: 'viml', conceptId: '1', designation: 'accuracy', language: 'fra' });
+
+    const result = deduplicateSearchHits([hit1, hit2]);
+    expect(result.length).toBe(1);
+  });
+
+  it('keeps designation match over id match for same concept', () => {
+    const idHit = makeHit({ registerId: 'viml', conceptId: '1', matchField: 'id' });
+    const desHit = makeHit({ registerId: 'viml', conceptId: '1', matchField: 'designation' });
+
+    const result = deduplicateSearchHits([idHit, desHit]);
+    expect(result.length).toBe(1);
+    expect(result[0].matchField).toBe('designation');
+  });
+
+  it('keeps first designation match when both are designation', () => {
+    const hit1 = makeHit({ registerId: 'viml', conceptId: '1', matchField: 'designation', language: 'eng' });
+    const hit2 = makeHit({ registerId: 'viml', conceptId: '1', matchField: 'designation', language: 'fra' });
+
+    const result = deduplicateSearchHits([hit1, hit2]);
+    expect(result.length).toBe(1);
+    expect(result[0].language).toBe('eng');
+  });
+
+  it('keeps hits from different datasets separate', () => {
+    const hit1 = makeHit({ registerId: 'viml-2022', conceptId: '1' });
+    const hit2 = makeHit({ registerId: 'viml-2013', conceptId: '1' });
+
+    const result = deduplicateSearchHits([hit1, hit2]);
+    expect(result.length).toBe(2);
+  });
+});

package/src/__tests__/test-helpers.ts

@@ -46,6 +46,8 @@ export interface AdapterStubOptions {
   extractEdges?: () => any[];
   extractDomainEdges?: () => any[];
   getIndexEntry?: () => any;
+  loadEdgeIndex?: () => Promise<any[]>;
+  loadDomainNodes?: () => Promise<any[]>;
 }
 
 export function makeAdapterStub(options: AdapterStubOptions = {}): any {
@@ -65,6 +67,8 @@ export function makeAdapterStub(options: AdapterStubOptions = {}): any {
     extractEdges: options.extractEdges ?? (() => []),
     extractDomainEdges: options.extractDomainEdges ?? (() => []),
     getIndexEntry: options.getIndexEntry ?? (() => null),
+    loadEdgeIndex: options.loadEdgeIndex ?? (() => Promise.resolve([])),
+    loadDomainNodes: options.loadDomainNodes ?? (() => Promise.resolve([])),
   };
 }
 

package/src/__tests__/utils-barrel.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import { DEFAULT_LANG } from '../utils/lang';
+import { deduplicateSearchHits } from '../utils/search';
+
+describe('DEFAULT_LANG single source', () => {
+  it('exports "eng"', () => {
+    expect(DEFAULT_LANG).toBe('eng');
+  });
+});
+
+describe('deduplicateSearchHits export', () => {
+  it('is a function', () => {
+    expect(typeof deduplicateSearchHits).toBe('function');
+  });
+});

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

@@ -0,0 +1,291 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { useVocabularyStore } from '../stores/vocabulary';
+import { createTestRouter, setupPinia, makeManifest, makeAdapterStub, makeSearchHit } from './test-helpers';
+import { conceptFromJson } from '../adapters/model-bridge';
+import { getFactory } from '../adapters/factory';
+
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+function mockJsonResponse(data: any) {
+  return Promise.resolve({
+    ok: true,
+    status: 200,
+    json: () => Promise.resolve(data),
+  } as Response);
+}
+
+function makeConcept() {
+  return conceptFromJson({
+    '@id': 'https://glossarist.org/test/concept/1',
+    '@type': 'gl:Concept',
+    'gl:localizedConcept': {
+      eng: {
+        '@type': 'gl:LocalizedConcept',
+        'gl:languageCode': 'eng',
+        'gl:designation': [{ '@type': 'gl:Expression', 'gl:term': 'test' }],
+      },
+    },
+  });
+}
+
+describe('vocabulary store — layered loading', () => {
+  let pinia: ReturnType<typeof setupPinia>;
+
+  beforeEach(() => {
+    pinia = setupPinia();
+    mockFetch.mockReset();
+    (getFactory() as any).crossRefIndex = null;
+  });
+
+  describe('loadDataset', () => {
+    it('does not fetch edges or domain nodes', async () => {
+      const store = useVocabularyStore();
+
+      // Set up adapter with edge/domain tracking
+      let edgeFetchCount = 0;
+      let domainFetchCount = 0;
+      const adapter = makeAdapterStub();
+      adapter.loadEdgeIndex = () => { edgeFetchCount++; return Promise.resolve([]); };
+      adapter.loadDomainNodes = () => { domainFetchCount++; return Promise.resolve([]); };
+
+      store.datasets.set('test', adapter);
+      store.manifests.set('test', makeManifest());
+
+      // The store's loadDataset calls factory.loadDataset which requires adapter
+      // to be registered with the factory. Since we test via viewConcept path,
+      // verify that after concept view, only targeted edges are loaded.
+      // For the store-level test, we verify loadDataset doesn't call loadEdges.
+      // Since loadDataset now only does factory.loadDataset, the adapter stub
+      // won't have its edge methods called.
+
+      // Direct test: viewConcept triggers ensureEdgesForDataset
+      adapter.fetchConcept = () => Promise.resolve(makeConcept());
+      adapter.manifest = makeManifest();
+
+      mockFetch.mockImplementation((url: string) => {
+        if (url.endsWith('cross-ref-index.json')) {
+          return mockJsonResponse({ test: [] });
+        }
+        return Promise.resolve({ ok: false, status: 404 } as Response);
+      });
+
+      await store.viewConcept('test', '1');
+
+      // Should load own edges (once) + domain nodes (once)
+      expect(edgeFetchCount).toBe(1);
+      expect(domainFetchCount).toBe(1);
+    });
+  });
+
+  describe('ensureEdgesForDataset', () => {
+    it('loads cross-referenced dataset edges via cross-ref-index', async () => {
+      const store = useVocabularyStore();
+
+      mockFetch.mockImplementation((url: string) => {
+        if (url.endsWith('cross-ref-index.json')) {
+          return mockJsonResponse({ 'viml-2022': ['viml-2013', 'viml-2000'] });
+        }
+        if (url.endsWith('edges.json')) {
+          return mockJsonResponse({ edges: [] });
+        }
+        if (url.endsWith('domain-nodes.json')) {
+          return mockJsonResponse({ domainNodes: [] });
+        }
+        return Promise.resolve({ ok: false, status: 404 } as Response);
+      });
+
+      let viml2013EdgeLoads = 0;
+      let viml2000EdgeLoads = 0;
+      let unrelatedEdgeLoads = 0;
+
+      const viml2022 = makeAdapterStub();
+      viml2022.fetchConcept = () => Promise.resolve(makeConcept());
+      viml2022.manifest = makeManifest({ id: 'viml-2022' });
+
+      const viml2013 = makeAdapterStub();
+      viml2013.loadEdgeIndex = () => { viml2013EdgeLoads++; return Promise.resolve([]); };
+      viml2013.loadDomainNodes = () => Promise.resolve([]);
+      viml2013.manifest = makeManifest({ id: 'viml-2013' });
+
+      const viml2000 = makeAdapterStub();
+      viml2000.loadEdgeIndex = () => { viml2000EdgeLoads++; return Promise.resolve([]); };
+      viml2000.loadDomainNodes = () => Promise.resolve([]);
+      viml2000.manifest = makeManifest({ id: 'viml-2000' });
+
+      const unrelated = makeAdapterStub();
+      unrelated.loadEdgeIndex = () => { unrelatedEdgeLoads++; return Promise.resolve([]); };
+      unrelated.loadDomainNodes = () => Promise.resolve([]);
+      unrelated.manifest = makeManifest({ id: 'unrelated' });
+
+      store.datasets.set('viml-2022', viml2022);
+      store.datasets.set('viml-2013', viml2013);
+      store.datasets.set('viml-2000', viml2000);
+      store.datasets.set('unrelated', unrelated);
+
+      await store.viewConcept('viml-2022', '1');
+
+      // viml-2013 and viml-2000 edges should be loaded (cross-referenced)
+      expect(viml2013EdgeLoads).toBe(1);
+      expect(viml2000EdgeLoads).toBe(1);
+      // unrelated dataset should NOT be loaded
+      expect(unrelatedEdgeLoads).toBe(0);
+    });
+
+    it('skips datasets already loaded', async () => {
+      const store = useVocabularyStore();
+
+      // Pre-load edges for viml-2013
+      store.edgeStatus['viml-2013'] = { loaded: true, count: 100 };
+
+      let viml2013EdgeLoads = 0;
+      mockFetch.mockImplementation((url: string) => {
+        if (url.endsWith('cross-ref-index.json')) {
+          return mockJsonResponse({ 'viml-2022': ['viml-2013'] });
+        }
+        if (url.includes('viml-2013') && url.endsWith('edges.json')) {
+          viml2013EdgeLoads++;
+          return mockJsonResponse({ edges: [] });
+        }
+        if (url.endsWith('edges.json')) {
+          return mockJsonResponse({ edges: [] });
+        }
+        if (url.endsWith('domain-nodes.json')) {
+          return mockJsonResponse({ domainNodes: [] });
+        }
+        return Promise.resolve({ ok: false, status: 404 } as Response);
+      });
+
+      const viml2022 = makeAdapterStub();
+      viml2022.fetchConcept = () => Promise.resolve(makeConcept());
+      viml2022.manifest = makeManifest({ id: 'viml-2022' });
+
+      const viml2013 = makeAdapterStub();
+      viml2013.loadEdgeIndex = () => { viml2013EdgeLoads++; return Promise.resolve([]); };
+      viml2013.loadDomainNodes = () => Promise.resolve([]);
+      viml2013.manifest = makeManifest({ id: 'viml-2013' });
+
+      store.datasets.set('viml-2022', viml2022);
+      store.datasets.set('viml-2013', viml2013);
+      store.manifests.set('viml-2022', makeManifest({ id: 'viml-2022' }));
+      store.manifests.set('viml-2013', makeManifest({ id: 'viml-2013' }));
+
+      await store.viewConcept('viml-2022', '1');
+
+      // viml-2013 edges should NOT be re-loaded
+      expect(viml2013EdgeLoads).toBe(0);
+    });
+  });
+
+  describe('searchAcrossDatasets — two-pass', () => {
+    it('returns results from loaded data without loading chunks', async () => {
+      const store = useVocabularyStore();
+      store.initialized = true;
+
+      let chunksLoaded = false;
+
+      const adapter = makeAdapterStub({
+        concepts: Array.from({ length: 25 }, (_, i) => ({
+          id: `${i + 1}`,
+          designations: { eng: `concept ${i + 1}` },
+          eng: `concept ${i + 1}`,
+          status: 'valid',
+        })),
+      });
+      adapter.manifest = makeManifest();
+      adapter.index = { concepts: adapter.getConcepts(), conceptCount: 25, registerId: 'test', schemaVersion: '1.0', chunkSize: 500, chunks: [] };
+      adapter.search = () => Array.from({ length: 25 }, (_, i) =>
+        makeSearchHit({ conceptId: `${i + 1}`, designation: `concept ${i + 1}` })
+      );
+      adapter.ensureAllChunksLoaded = () => {
+        chunksLoaded = true;
+        return Promise.resolve();
+      };
+
+      store.datasets.set('test', adapter);
+
+      const results = await store.searchAcrossDatasets('concept');
+
+      expect(results.length).toBe(25);
+      // With ≥20 results, chunks should NOT be loaded
+      expect(chunksLoaded).toBe(false);
+    });
+
+    it('loads chunks for adapters with zero index hits when total is under threshold', async () => {
+      const store = useVocabularyStore();
+      store.initialized = true;
+
+      let adapter1ChunksLoaded = false;
+      let adapter2ChunksLoaded = false;
+
+      // Adapter 1: has a few results in index (5 hits)
+      const adapter1 = makeAdapterStub({
+        concepts: Array.from({ length: 5 }, (_, i) => ({
+          id: `${i + 1}`,
+          designations: { eng: `item ${i + 1}` },
+          eng: `item ${i + 1}`,
+          status: 'valid',
+        })),
+      });
+      adapter1.manifest = makeManifest({ id: 'ds1' });
+      adapter1.registerId = 'ds1';
+      adapter1.index = { concepts: adapter1.getConcepts(), conceptCount: 5, registerId: 'ds1', schemaVersion: '1.0', chunkSize: 500, chunks: [] };
+      adapter1.search = () => Array.from({ length: 5 }, (_, i) =>
+        makeSearchHit({ registerId: 'ds1', conceptId: `${i + 1}`, designation: `item ${i + 1}` })
+      );
+      adapter1.ensureAllChunksLoaded = () => {
+        adapter1ChunksLoaded = true;
+        return Promise.resolve();
+      };
+
+      // Adapter 2: has no results in index but will find some after chunk loading
+      const adapter2 = makeAdapterStub();
+      adapter2.manifest = makeManifest({ id: 'ds2' });
+      adapter2.registerId = 'ds2';
+      adapter2.index = { concepts: [], conceptCount: 0, registerId: 'ds2', schemaVersion: '1.0', chunkSize: 500, chunks: [] };
+      adapter2.search = () => [];
+      let adapter2CalledAfterChunkLoad = false;
+      adapter2.ensureAllChunksLoaded = () => {
+        adapter2ChunksLoaded = true;
+        // After chunks load, search returns results
+        adapter2.search = () => [makeSearchHit({ registerId: 'ds2', conceptId: '100', designation: 'item hidden' })];
+        return Promise.resolve();
+      };
+
+      store.datasets.set('ds1', adapter1);
+      store.datasets.set('ds2', adapter2);
+
+      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)
+      expect(adapter2ChunksLoaded).toBe(true);
+    });
+
+    it('does not load chunks when adapter search has 0 hits from index', async () => {
+      const store = useVocabularyStore();
+      store.initialized = true;
+
+      let chunksLoaded = false;
+
+      const adapter = makeAdapterStub();
+      adapter.manifest = makeManifest();
+      adapter.index = { concepts: [], conceptCount: 0, registerId: 'test', schemaVersion: '1.0', chunkSize: 500, chunks: [] };
+      adapter.search = () => [];
+      adapter.ensureAllChunksLoaded = () => {
+        chunksLoaded = true;
+        return Promise.resolve();
+      };
+
+      store.datasets.set('test', adapter);
+
+      const results = await store.searchAcrossDatasets('nonexistent');
+
+      expect(results.length).toBe(0);
+      // Should still try loading chunks for the adapter that found nothing
+      expect(chunksLoaded).toBe(true);
+    });
+  });
+});

package/src/adapters/DatasetAdapter.ts

@@ -7,6 +7,7 @@ import type {
   GraphEdge,
   GraphNode,
   SectionNode,
+  DatasetSummary,
 } from './types';
 import type { Concept, LocalizedConcept, Designation } from 'glossarist';
 import { conceptFromJson, conceptUri } from './model-bridge';
@@ -37,8 +38,10 @@ export class DatasetAdapter {
   private baseUrl: string;
   manifest: Manifest | null = null;
   index: ConceptIndex | null = null;
+  private manifestComplete = false;
 
   private conceptCache = new Map<string, Concept>();
+  private static MAX_CACHE = 100;
   private summaryMap = new Map<string, ConceptSummary>();
   private loadedChunks = new Set<number>();
   private indexMeta: { conceptCount: number; chunkSize: number; chunks: { file: string; count: number }[] } | null = null;
@@ -48,10 +51,37 @@ export class DatasetAdapter {
     this.baseUrl = baseUrl;
   }
 
+  setSummaryManifest(summary: DatasetSummary): void {
+    this.manifest = {
+      id: this.registerId,
+      datasetUri: '',
+      title: summary.title,
+      description: summary.description,
+      owner: summary.owner,
+      baseUrl: this.baseUrl,
+      languages: summary.languages,
+      conceptCount: summary.conceptCount,
+      conceptUrlTemplate: '',
+      indexUrl: '',
+      contextUrl: '',
+      uriBase: '',
+      status: '',
+      schemaVersion: '',
+      tags: summary.tags,
+      lastUpdated: '',
+      sourceRepo: '',
+      chunkSize: 1000,
+      color: summary.color,
+    };
+    this.manifestComplete = false;
+  }
+
   async loadManifest(): Promise<Manifest> {
+    if (this.manifestComplete && this.manifest) return this.manifest;
     const resp = await fetch(`${this.baseUrl}/manifest.json`);
     if (!resp.ok) throw new Error(`Failed to load manifest for ${this.registerId}: ${resp.status}`);
     this.manifest = (await resp.json()) as Manifest;
+    this.manifestComplete = true;
     return this.manifest;
   }
 
@@ -79,6 +109,7 @@ export class DatasetAdapter {
       designations: c.designations || {},
       eng: c.eng || c.designations?.eng || Object.values(c.designations || {})[0] || '',
       status: c.status,
+      groups: c.groups || [],
     }));
 
     return {
@@ -166,6 +197,7 @@ export class DatasetAdapter {
         designations,
         eng: designations.eng || Object.values(designations)[0] || '',
         status: entry.status,
+        groups: entry.groups || [],
       };
       this.index!.concepts[startPos + i] = summary;
       this.summaryMap.set(entry.id, summary);
@@ -207,13 +239,21 @@ export class DatasetAdapter {
 
   async fetchConcept(conceptId: string): Promise<Concept> {
     const cached = this.conceptCache.get(conceptId);
-    if (cached) return cached;
+    if (cached) {
+      this.conceptCache.delete(conceptId);
+      this.conceptCache.set(conceptId, cached);
+      return cached;
+    }
 
     const resp = await fetch(`${this.baseUrl}/concepts/${conceptId}.json`);
     if (!resp.ok) throw new Error(`Concept ${conceptId} not found in ${this.registerId}`);
     const json = await resp.json();
     const concept = conceptFromJson(json);
     this.conceptCache.set(conceptId, concept);
+    if (this.conceptCache.size > DatasetAdapter.MAX_CACHE) {
+      const oldest = this.conceptCache.keys().next().value;
+      if (oldest !== undefined) this.conceptCache.delete(oldest);
+    }
     return concept;
   }