@glossarist/concept-browser 0.1.0

package/src/App.vue

@@ -0,0 +1,98 @@
+<script setup lang="ts">
+import { onMounted, onUnmounted, ref } from 'vue';
+import { useVocabularyStore } from './stores/vocabulary';
+import { useSiteConfig } from './config/use-site-config';
+import { buildPageRoutes } from './router/page-routes';
+import router from './router';
+import AppHeader from './components/AppHeader.vue';
+import AppSidebar from './components/AppSidebar.vue';
+
+const store = useVocabularyStore();
+const { loadConfig, config } = useSiteConfig();
+const appReady = ref(false);
+const showScrollTop = ref(false);
+let mainEl: HTMLElement | null = null;
+
+function onMainScroll() {
+  showScrollTop.value = (mainEl?.scrollTop ?? 0) > 400;
+}
+
+function scrollToTop() {
+  mainEl?.scrollTo({ top: 0, behavior: 'smooth' });
+}
+
+onMounted(async () => {
+  const [, cfg] = await Promise.all([store.discoverDatasets(), loadConfig()]);
+  if (cfg?.pages) {
+    for (const route of buildPageRoutes(cfg.pages)) {
+      router.addRoute(route);
+    }
+  }
+  appReady.value = true;
+  // Watch scroll on main content area
+  mainEl = document.querySelector('main');
+  mainEl?.addEventListener('scroll', onMainScroll, { passive: true });
+});
+
+onUnmounted(() => {
+  mainEl?.removeEventListener('scroll', onMainScroll);
+});
+</script>
+
+<template>
+  <div class="min-h-screen bg-surface flex flex-col">
+    <AppHeader />
+    <div class="flex flex-1 overflow-hidden">
+      <AppSidebar />
+      <main class="flex-1 overflow-y-auto bg-surface">
+        <div v-if="!appReady" class="flex items-center justify-center h-[70vh]">
+          <div class="w-full max-w-md px-6 space-y-6">
+            <!-- Title skeleton -->
+            <div class="space-y-3">
+              <div class="skeleton h-3 w-24"></div>
+              <div class="skeleton h-10 w-64"></div>
+              <div class="skeleton h-4 w-80"></div>
+              <div class="skeleton h-4 w-56"></div>
+            </div>
+            <!-- Stats skeleton -->
+            <div class="flex gap-4">
+              <div class="skeleton h-16 flex-1"></div>
+              <div class="skeleton h-16 flex-1"></div>
+              <div class="skeleton h-16 flex-1"></div>
+            </div>
+            <!-- Card skeleton -->
+            <div class="flex gap-4">
+              <div class="skeleton h-40 flex-1"></div>
+              <div class="skeleton h-40 flex-1"></div>
+              <div class="skeleton h-40 flex-1"></div>
+            </div>
+          </div>
+        </div>
+        <template v-else>
+          <div v-if="store.error && !store.currentConcept" class="max-w-xl mx-auto text-center py-24">
+            <div class="card p-8 border-red-200 bg-red-50/50">
+              <p class="text-red-700 font-medium mb-1">Error loading data</p>
+              <p class="text-sm text-red-600/80">{{ store.error }}</p>
+            </div>
+          </div>
+          <router-view v-slot="{ Component }">
+            <transition name="page" mode="out-in">
+              <component :is="Component" :key="$route.fullPath" />
+            </transition>
+          </router-view>
+        </template>
+      </main>
+    </div>
+    <!-- Scroll-to-top -->
+    <transition name="page">
+      <button
+        v-if="showScrollTop"
+        @click="scrollToTop"
+        aria-label="Scroll to top"
+        class="fixed bottom-6 right-6 z-40 w-10 h-10 bg-surface-raised border border-ink-100 rounded-full flex items-center justify-center shadow-md hover:shadow-lg hover:bg-ink-50 transition-all"
+      >
+        <svg class="w-4 h-4 text-ink-500" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 15l7-7 7 7"/></svg>
+      </button>
+    </transition>
+  </div>
+</template>

package/src/__tests__/data-integration.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { AdapterFactory } 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);
+}
+
+describe('AdapterFactory', () => {
+  let factory: AdapterFactory;
+
+  beforeEach(() => {
+    factory = new AdapterFactory();
+    mockFetch.mockReset();
+  });
+
+  describe('discoverDatasets', () => {
+    it('creates adapters from dataset registry', async () => {
+      mockFetch.mockReturnValue(mockJsonResponse([
+        { id: 'iev', manifestUrl: '/data/iev/manifest.json' },
+        { id: 'isotc211', manifestUrl: '/data/isotc211/manifest.json' },
+        { id: 'isotc204', manifestUrl: '/data/isotc204/manifest.json' },
+      ]));
+
+      const adapters = await factory.discoverDatasets('/datasets.json');
+      expect(adapters.length).toBe(3);
+      expect(adapters[0].registerId).toBe('iev');
+      expect(factory.getAdapters().length).toBe(3);
+    });
+
+    it('throws on failed fetch', async () => {
+      mockFetch.mockReturnValue(Promise.resolve({
+        ok: false,
+        status: 500,
+      } as Response));
+
+      await expect(factory.discoverDatasets('/bad-url')).rejects.toThrow('Failed to load dataset registry');
+    });
+  });
+
+  describe('loadDataset', () => {
+    it('loads manifest, index, and registers with UriRouter', async () => {
+      // Setup: discover first
+      mockFetch.mockReturnValueOnce(mockJsonResponse([
+        { id: 'test', manifestUrl: '/data/test/manifest.json' },
+      ]));
+      await factory.discoverDatasets('/datasets.json');
+
+      // Load manifest
+      mockFetch.mockReturnValueOnce(mockJsonResponse({
+        id: 'test',
+        datasetUri: 'https://glossarist.org/test/*',
+        title: 'Test',
+        languages: ['eng'],
+        chunkSize: 500,
+      }));
+
+      // Load index
+      mockFetch.mockReturnValueOnce(mockJsonResponse({
+        registerId: 'test',
+        conceptCount: 2,
+        chunkSize: 500,
+        chunks: [],
+        concepts: [
+          { id: '102-01-01', eng: 'equality', status: 'Standard' },
+          { id: '102-01-02', eng: 'value', status: 'Standard' },
+        ],
+      }));
+
+      const adapter = await factory.loadDataset('test');
+      expect(adapter.manifest?.title).toBe('Test');
+      expect(adapter.getConcepts().length).toBe(2);
+
+      // Resolver should now resolve internal URIs
+      const resolved = factory.resolve('https://glossarist.org/test/concept/102-01-01');
+      expect(resolved.type).toBe('internal');
+      if (resolved.type === 'internal') {
+        expect(resolved.registerId).toBe('test');
+        expect(resolved.conceptId).toBe('102-01-01');
+      }
+    });
+
+    it('returns undefined for unknown dataset', () => {
+      expect(factory.getAdapter('nonexistent')).toBeUndefined();
+    });
+
+    it('resolve returns unresolved when dataset not loaded', () => {
+      const resolved = factory.resolve('https://glossarist.org/unknown/concept/123');
+      expect(resolved.type).toBe('unresolved');
+    });
+  });
+
+  describe('cross-register resolution', () => {
+    it('resolves URIs across multiple loaded datasets', async () => {
+      mockFetch.mockReturnValueOnce(mockJsonResponse([
+        { id: 'iev', manifestUrl: '/data/iev/manifest.json' },
+        { id: 'isotc204', manifestUrl: '/data/isotc204/manifest.json' },
+      ]));
+      await factory.discoverDatasets('/datasets.json');
+
+      // Load IEV
+      mockFetch.mockReturnValueOnce(mockJsonResponse({
+        id: 'iev', datasetUri: 'urn:iec:std:iec:60050:*', title: 'IEV', languages: ['eng'], chunkSize: 500,
+      }));
+      mockFetch.mockReturnValueOnce(mockJsonResponse({
+        registerId: 'iev', conceptCount: 0, chunkSize: 500, chunks: [], concepts: [],
+      }));
+      await factory.loadDataset('iev');
+
+      // Load TC 204
+      mockFetch.mockReturnValueOnce(mockJsonResponse({
+        id: 'isotc204', datasetUri: 'urn:iso:std:iso:14812:*', title: 'TC 204', languages: ['eng'], chunkSize: 500,
+      }));
+      mockFetch.mockReturnValueOnce(mockJsonResponse({
+        registerId: 'isotc204', conceptCount: 0, chunkSize: 500, chunks: [], concepts: [],
+      }));
+      await factory.loadDataset('isotc204');
+
+      // Cross-register resolution
+      const ievRes = factory.resolve('https://glossarist.org/iev/concept/103-01-02');
+      expect(ievRes.type).toBe('internal');
+      if (ievRes.type === 'internal') expect(ievRes.registerId).toBe('iev');
+
+      const tcRes = factory.resolve('https://glossarist.org/isotc204/concept/3.1.1.1');
+      expect(tcRes.type).toBe('internal');
+      if (tcRes.type === 'internal') expect(tcRes.registerId).toBe('isotc204');
+    });
+  });
+});

package/src/__tests__/data-integrity.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+
+const PUBLIC_DATA = path.resolve(__dirname, '../../public/data');
+const DATASETS_JSON = path.resolve(PUBLIC_DATA, '..', 'datasets.json');
+
+const hasData = fs.existsSync(DATASETS_JSON);
+const datasets: string[] = hasData
+  ? JSON.parse(fs.readFileSync(DATASETS_JSON, 'utf8')).map((d: any) => d.id)
+  : [];
+
+describe.skipIf(!hasData || datasets.length === 0)('Data integrity', () => {
+  it('has valid datasets.json', () => {
+    const data = JSON.parse(fs.readFileSync(DATASETS_JSON, 'utf8'));
+    expect(data.length).toBeGreaterThan(0);
+    for (const d of data) {
+      expect(d.id).toBeTruthy();
+      expect(d.manifestUrl).toBeTruthy();
+    }
+  });
+
+  for (const ds of datasets) {
+    describe(`${ds}`, () => {
+      const dsDir = path.join(PUBLIC_DATA, ds);
+
+      it('has manifest.json with required fields', () => {
+        const file = path.join(dsDir, 'manifest.json');
+        expect(fs.existsSync(file)).toBe(true);
+        const m = JSON.parse(fs.readFileSync(file, 'utf8'));
+        expect(m.id).toBe(ds);
+        expect(m.title).toBeTruthy();
+        expect(m.conceptCount).toBeGreaterThan(0);
+        expect(m.languages.length).toBeGreaterThan(0);
+        expect(m.chunkSize).toBe(500);
+        expect(m.baseUrl).toBe(`/data/${ds}`);
+      });
+
+      it('has index.json with valid summary entries', () => {
+        const file = path.join(dsDir, 'index.json');
+        expect(fs.existsSync(file)).toBe(true);
+        const idx = JSON.parse(fs.readFileSync(file, 'utf8'));
+        expect(idx.registerId).toBe(ds);
+        expect(idx.conceptCount).toBe(idx.concepts.length);
+        expect(idx.chunkSize).toBe(500);
+        expect(idx.chunks.length).toBeGreaterThan(0);
+
+        for (const c of idx.concepts) {
+          expect(c.id).toBeTruthy();
+          expect(typeof c.eng).toBe('string');
+          expect(c.status).toBeTruthy();
+        }
+      });
+
+      it('concept count matches files on disk', () => {
+        const conceptsDir = path.join(dsDir, 'concepts');
+        expect(fs.existsSync(conceptsDir)).toBe(true);
+        const files = fs.readdirSync(conceptsDir).filter(f => f.endsWith('.json'));
+        const idx = JSON.parse(fs.readFileSync(path.join(dsDir, 'index.json'), 'utf8'));
+        expect(files.length).toBe(idx.conceptCount);
+      });
+
+      it('sample concepts are valid JSON-LD', () => {
+        const conceptsDir = path.join(dsDir, 'concepts');
+        const files = fs.readdirSync(conceptsDir).filter(f => f.endsWith('.json'));
+
+        const samples = [
+          files[0],
+          files[Math.floor(files.length / 2)],
+          files[files.length - 1],
+        ];
+
+        for (const file of samples) {
+          const data = JSON.parse(fs.readFileSync(path.join(conceptsDir, file), 'utf8'));
+          expect(data['@context']).toBe('https://glossarist.org/ns/context.jsonld');
+          expect(data['@id']).toContain(`/concept/`);
+          expect(data['@type']).toBe('gl:Concept');
+          expect(data['gl:identifier']).toBeTruthy();
+          expect(data['gl:localizedConcept']).toBeTruthy();
+          expect(Object.keys(data['gl:localizedConcept']).length).toBeGreaterThan(0);
+        }
+      });
+
+      it('index chunk files exist and have correct counts', () => {
+        const idx = JSON.parse(fs.readFileSync(path.join(dsDir, 'index.json'), 'utf8'));
+        const chunksDir = path.join(dsDir, 'chunks');
+        expect(fs.existsSync(chunksDir)).toBe(true);
+
+        let totalFromChunks = 0;
+        for (const chunk of idx.chunks) {
+          const chunkFile = path.join(chunksDir, chunk.file);
+          expect(fs.existsSync(chunkFile)).toBe(true);
+          const chunkData = JSON.parse(fs.readFileSync(chunkFile, 'utf8'));
+          expect(chunkData.concepts.length).toBe(chunk.count);
+          totalFromChunks += chunk.count;
+        }
+        expect(totalFromChunks).toBe(idx.conceptCount);
+      });
+    });
+  }
+});

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

@@ -0,0 +1,336 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DatasetAdapter } from '../adapters/DatasetAdapter';
+
+// Mock fetch globally
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+function mockJsonResponse(data: any) {
+  return Promise.resolve({
+    ok: true,
+    status: 200,
+    json: () => Promise.resolve(data),
+  } as Response);
+}
+
+describe('DatasetAdapter', () => {
+  let adapter: DatasetAdapter;
+
+  beforeEach(() => {
+    adapter = new DatasetAdapter('test', '/data/test');
+    mockFetch.mockReset();
+  });
+
+  describe('loadManifest', () => {
+    it('loads and stores the manifest', async () => {
+      const manifest = {
+        id: 'test',
+        title: 'Test Dataset',
+        description: 'A test',
+        owner: 'Test',
+        baseUrl: '/data/test',
+        languages: ['eng', 'fra'],
+        conceptCount: 100,
+        chunkSize: 500,
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(manifest));
+
+      const result = await adapter.loadManifest();
+      expect(result.title).toBe('Test Dataset');
+      expect(adapter.manifest?.id).toBe('test');
+      expect(mockFetch).toHaveBeenCalledWith('/data/test/manifest.json');
+    });
+
+    it('throws on fetch failure', async () => {
+      mockFetch.mockReturnValue(Promise.resolve({
+        ok: false,
+        status: 404,
+      } as Response));
+
+      await expect(adapter.loadManifest()).rejects.toThrow('Failed to load manifest');
+    });
+  });
+
+  describe('loadIndex', () => {
+    it('loads and indexes concept summaries', async () => {
+      const index = {
+        registerId: 'test',
+        schemaVersion: '1.0.0',
+        conceptCount: 3,
+        chunkSize: 500,
+        chunks: [],
+        concepts: [
+          { id: '102-01-01', eng: 'equality', status: 'Standard' },
+          { id: '102-01-02', eng: 'inequality', status: 'Standard' },
+          { id: '103-01-02', eng: 'functional', status: 'Standard' },
+        ],
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(index));
+
+      await adapter.loadIndex();
+      expect(adapter.getConcepts().length).toBe(3);
+      expect(adapter.getIndexEntry('103-01-02')?.eng).toBe('functional');
+      expect(adapter.getConceptCount()).toBe(3);
+    });
+  });
+
+  describe('fetchConcept', () => {
+    it('fetches and caches concept documents', async () => {
+      const concept = {
+        '@context': 'https://glossarist.org/ns/context.jsonld',
+        '@id': 'https://glossarist.org/test/concept/103-01-02',
+        '@type': 'gl:Concept',
+        'gl:identifier': '103-01-02',
+        'gl:localizedConcept': {
+          eng: {
+            '@id': 'https://glossarist.org/test/concept/103-01-02/eng',
+            '@type': 'gl:LocalizedConcept',
+            'gl:languageCode': 'eng',
+            'gl:designation': [
+              { '@type': 'gl:Expression', 'gl:normativeStatus': 'preferred', 'gl:term': 'functional' },
+            ],
+            'gl:definition': [
+              { '@type': 'gl:DetailedDefinition', 'gl:content': 'A functional relationship...' },
+            ],
+          },
+        },
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(concept));
+
+      const result = await adapter.fetchConcept('103-01-02');
+      expect(result['gl:identifier']).toBe('103-01-02');
+      expect(mockFetch).toHaveBeenCalledWith('/data/test/concepts/103-01-02.json');
+
+      // Second call should use cache
+      mockFetch.mockReset();
+      const cached = await adapter.fetchConcept('103-01-02');
+      expect(cached['gl:identifier']).toBe('103-01-02');
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it('throws on missing concept', async () => {
+      mockFetch.mockReturnValue(Promise.resolve({
+        ok: false,
+        status: 404,
+      } as Response));
+
+      await expect(adapter.fetchConcept('nonexistent')).rejects.toThrow('not found');
+    });
+  });
+
+  describe('search', () => {
+    it('finds concepts by term substring', async () => {
+      const index = {
+        registerId: 'test',
+        schemaVersion: '1.0.0',
+        conceptCount: 3,
+        chunkSize: 500,
+        chunks: [],
+        concepts: [
+          { id: '102-01-01', eng: 'equality', status: 'Standard' },
+          { id: '102-01-02', eng: 'inequality', status: 'Standard' },
+          { id: '103-01-02', eng: 'functional', status: 'Standard' },
+        ],
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(index));
+      await adapter.loadIndex();
+
+      const hits = adapter.search('func');
+      expect(hits.length).toBe(1);
+      expect(hits[0].conceptId).toBe('103-01-02');
+      expect(hits[0].designation).toBe('functional');
+    });
+
+    it('finds concepts by ID', async () => {
+      const index = {
+        registerId: 'test',
+        schemaVersion: '1.0.0',
+        conceptCount: 1,
+        chunkSize: 500,
+        chunks: [],
+        concepts: [
+          { id: '103-01-02', eng: 'functional', status: 'Standard' },
+        ],
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(index));
+      await adapter.loadIndex();
+
+      const hits = adapter.search('103-01-02');
+      expect(hits.length).toBe(1);
+      expect(hits[0].conceptId).toBe('103-01-02');
+    });
+
+    it('is case insensitive', async () => {
+      const index = {
+        registerId: 'test',
+        schemaVersion: '1.0.0',
+        conceptCount: 1,
+        chunkSize: 500,
+        chunks: [],
+        concepts: [
+          { id: '102-01-01', eng: 'Equality', status: 'Standard' },
+        ],
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(index));
+      await adapter.loadIndex();
+
+      const hits = adapter.search('EQUALITY');
+      expect(hits.length).toBe(1);
+    });
+
+    it('returns empty for no match', async () => {
+      const index = {
+        registerId: 'test',
+        schemaVersion: '1.0.0',
+        conceptCount: 1,
+        chunkSize: 500,
+        chunks: [],
+        concepts: [
+          { id: '102-01-01', eng: 'equality', status: 'Standard' },
+        ],
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(index));
+      await adapter.loadIndex();
+
+      const hits = adapter.search('xyznotfound');
+      expect(hits.length).toBe(0);
+    });
+  });
+
+  describe('extractEdges', () => {
+    it('extracts cross-reference edges from gl:references', () => {
+      const concept = {
+        '@id': 'https://glossarist.org/test/concept/102-01-01',
+        'gl:localizedConcept': {
+          eng: {
+            'gl:references': [
+              { '@id': 'https://glossarist.org/iev/concept/103-01-02', 'gl:term': 'functional' },
+              { '@id': 'https://glossarist.org/iev/concept/102-01-02', 'gl:term': 'inequality' },
+            ],
+          },
+        },
+      };
+
+      const edges = adapter.extractEdges(concept as any);
+      expect(edges.length).toBe(2);
+      expect(edges[0].target).toBe('https://glossarist.org/iev/concept/103-01-02');
+      expect(edges[0].type).toBe('references');
+      expect(edges[0].label).toBe('functional');
+    });
+
+    it('skips self-references', () => {
+      const concept = {
+        '@id': 'https://glossarist.org/test/concept/102-01-01',
+        'gl:localizedConcept': {
+          eng: {
+            'gl:references': [
+              { '@id': 'https://glossarist.org/test/concept/102-01-01', 'gl:term': 'self' },
+            ],
+          },
+        },
+      };
+
+      const edges = adapter.extractEdges(concept as any);
+      expect(edges.length).toBe(0);
+    });
+
+    it('handles concepts with no references', () => {
+      const concept = {
+        '@id': 'https://glossarist.org/test/concept/102-01-01',
+        'gl:localizedConcept': {
+          eng: {},
+        },
+      };
+
+      const edges = adapter.extractEdges(concept as any);
+      expect(edges.length).toBe(0);
+    });
+
+    it('handles empty localizedConcept', () => {
+      const concept = {
+        '@id': 'https://glossarist.org/test/concept/102-01-01',
+        'gl:localizedConcept': {},
+      };
+
+      const edges = adapter.extractEdges(concept as any);
+      expect(edges.length).toBe(0);
+    });
+
+    it('collects references from multiple languages without duplication', () => {
+      const concept = {
+        '@id': 'https://glossarist.org/test/concept/102-01-01',
+        'gl:localizedConcept': {
+          eng: {
+            'gl:references': [
+              { '@id': 'https://glossarist.org/iev/concept/103-01-02', 'gl:term': 'functional' },
+            ],
+          },
+          fra: {
+            'gl:references': [
+              { '@id': 'https://glossarist.org/iev/concept/103-01-02', 'gl:term': 'fonctionnel' },
+            ],
+          },
+        },
+      };
+
+      // Same target from two languages — both edges are kept (different labels)
+      const edges = adapter.extractEdges(concept as any);
+      expect(edges.length).toBe(2);
+    });
+
+    it('extracts inline IEV cross-references from gl:references', () => {
+      const concept = {
+        '@id': 'https://glossarist.org/test/concept/112-01-01',
+        'gl:localizedConcept': {
+          eng: {
+            'gl:references': [
+              { '@id': 'https://glossarist.org/iev/concept/102-02-18', 'gl:term': 'scalar' },
+              { '@id': 'https://glossarist.org/iev/concept/112-01-14', 'gl:term': 'unit' },
+            ],
+          },
+        },
+      };
+
+      const edges = adapter.extractEdges(concept as any);
+      expect(edges.length).toBe(2);
+      expect(edges[0].target).toBe('https://glossarist.org/iev/concept/102-02-18');
+      expect(edges[0].label).toBe('scalar');
+      expect(edges[1].target).toBe('https://glossarist.org/iev/concept/112-01-14');
+      expect(edges[1].label).toBe('unit');
+    });
+
+    it('extracts inline URN cross-references from gl:references', () => {
+      const concept = {
+        '@id': 'https://glossarist.org/test/concept/3.1.1.1',
+        'gl:localizedConcept': {
+          eng: {
+            'gl:references': [
+              { '@id': 'https://glossarist.org/isotc204/concept/3.1.1.6', 'gl:term': 'entity' },
+            ],
+          },
+        },
+      };
+
+      const edges = adapter.extractEdges(concept as any);
+      expect(edges.length).toBe(1);
+      expect(edges[0].target).toBe('https://glossarist.org/isotc204/concept/3.1.1.6');
+      expect(edges[0].label).toBe('entity');
+    });
+  });
+
+  describe('getLanguages', () => {
+    it('returns languages from manifest', async () => {
+      const manifest = {
+        id: 'test', languages: ['eng', 'fra', 'deu'], chunkSize: 500,
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(manifest));
+      await adapter.loadManifest();
+
+      expect(adapter.getLanguages()).toEqual(['eng', 'fra', 'deu']);
+    });
+
+    it('returns empty array without manifest', () => {
+      expect(adapter.getLanguages()).toEqual([]);
+    });
+  });
+});