@glossarist/concept-browser 0.7.50 → 0.7.52

package/src/__tests__/errors/errors.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect } from 'vitest';
+import {
+  GlossaristError,
+  ConfigurationError,
+  DataSourceError,
+  SerializationError,
+  ValidationError,
+  UnknownDatasetError,
+  DatasetRegistryLoadError,
+  ManifestLoadError,
+  IndexLoadError,
+  ChunkLoadError,
+  ConceptNotFoundError,
+  NonVerbalEntityNotFoundError,
+  InvalidConceptIdentityError,
+  InvalidConceptUriError,
+  formatError,
+  isGlossaristError,
+} from '../../errors';
+
+describe('GlossaristError hierarchy', () => {
+  it('preserves the constructor name as Error#name', () => {
+    const err = new UnknownDatasetError('foo', { registerId: 'foo' });
+    expect(err.name).toBe('UnknownDatasetError');
+  });
+
+  it('attaches the context object verbatim', () => {
+    const err = ConceptNotFoundError.make('iso1', '3.1.1');
+    expect(err.context.registerId).toBe('iso1');
+    expect(err.context.conceptId).toBe('3.1.1');
+  });
+
+  it('branches inherit from the correct top-level class', () => {
+    expect(new UnknownDatasetError('x')).toBeInstanceOf(ConfigurationError);
+    expect(ConceptNotFoundError.make('r', 'c')).toBeInstanceOf(DataSourceError);
+    expect(new InvalidConceptIdentityError('bad')).toBeInstanceOf(SerializationError);
+    expect(new ValidationError('bad')).toBeInstanceOf(GlossaristError);
+  });
+
+  it('all errors are instanceof GlossaristError and Error', () => {
+    const cases = [
+      new UnknownDatasetError('x'),
+      new DataSourceError('x'),
+      new SerializationError('x'),
+      new ValidationError('x'),
+    ];
+    for (const err of cases) {
+      expect(err).toBeInstanceOf(GlossaristError);
+      expect(err).toBeInstanceOf(Error);
+    }
+  });
+});
+
+describe('factories', () => {
+  it('UnknownDatasetError.make produces a descriptive message', () => {
+    const err = UnknownDatasetError.make('iso-foobar');
+    expect(err.message).toContain('iso-foobar');
+    expect(err.context.registerId).toBe('iso-foobar');
+    expect(err.hint()).toMatch(/datasets/i);
+  });
+
+  it('DatasetRegistryLoadError.make captures status and URL', () => {
+    const err = DatasetRegistryLoadError.make(503, '/datasets.json');
+    expect(err.context.status).toBe(503);
+    expect(err.context.url).toBe('/datasets.json');
+  });
+
+  it('ManifestLoadError and IndexLoadError tag registerId', () => {
+    expect(ManifestLoadError.make('iso1', 500).context.registerId).toBe('iso1');
+    expect(IndexLoadError.make('iso1', 404).context.registerId).toBe('iso1');
+  });
+
+  it('ChunkLoadError records chunk index', () => {
+    const err = ChunkLoadError.make('iso1', 3, 500);
+    expect(err.context.chunkIndex).toBe(3);
+  });
+
+  it('ConceptNotFoundError formats a stable message', () => {
+    const err = ConceptNotFoundError.make('iso1', '3.1.1');
+    expect(err.message).toBe('Concept 3.1.1 not found in iso1');
+  });
+
+  it('NonVerbalEntityNotFoundError captures kind and id', () => {
+    const err = NonVerbalEntityNotFoundError.make('iso1', 'figure', 'fig-1', 404);
+    expect(err.context.kind).toBe('figure');
+    expect(err.context.entityId).toBe('fig-1');
+  });
+
+  it('InvalidConceptUriError.make formats a hint', () => {
+    const err = InvalidConceptUriError.make('https://example.com/foo');
+    expect(err.context.uri).toBe('https://example.com/foo');
+    expect(err.hint()).toContain('<uriBase>');
+  });
+
+  it('InvalidConceptIdentityError provides a hint', () => {
+    const err = new InvalidConceptIdentityError('bad');
+    expect(err.hint()).toMatch(/localId/);
+  });
+});
+
+describe('formatError', () => {
+  it('starts with the class name and message', () => {
+    const out = formatError(ConceptNotFoundError.make('iso1', '3.1.1'));
+    expect(out.split('\n')[0]).toBe('ConceptNotFoundError: Concept 3.1.1 not found in iso1');
+  });
+
+  it('renders context fields one per line', () => {
+    const out = formatError(ManifestLoadError.make('iso1', 500));
+    expect(out).toContain('registerId: iso1');
+    expect(out).toContain('status: 500');
+  });
+
+  it('appends the hint when present', () => {
+    const out = formatError(UnknownDatasetError.make('iso1'));
+    expect(out).toContain('hint:');
+  });
+
+  it('omits empty context', () => {
+    const out = formatError(new ValidationError('boom'));
+    expect(out).toBe('ValidationError: boom');
+  });
+
+  it('omits undefined fields but keeps zero/false values', () => {
+    const err = new ValidationError('boom', { count: 0, flag: false, missing: undefined });
+    const out = formatError(err);
+    expect(out).toContain('count: 0');
+    expect(out).toContain('flag: false');
+    expect(out).not.toContain('missing');
+  });
+});
+
+describe('isGlossaristError', () => {
+  it('returns true for any subclass of GlossaristError', () => {
+    expect(isGlossaristError(ConceptNotFoundError.make('r', 'c'))).toBe(true);
+  });
+
+  it('returns false for plain Errors and non-errors', () => {
+    expect(isGlossaristError(new Error('plain'))).toBe(false);
+    expect(isGlossaristError(null)).toBe(false);
+    expect(isGlossaristError('string')).toBe(false);
+  });
+});

package/src/__tests__/format-downloads.test.ts

@@ -1,6 +1,6 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, beforeEach } from 'vitest';
 import { mount } from '@vue/test-utils';
-import { createPinia, setActivePinia } from 'pinia';
+import { createPinia } from 'pinia';
 import { createRouter, createMemoryHistory } from 'vue-router';
 import FormatDownloads from '../components/FormatDownloads.vue';
 
@@ -13,86 +13,68 @@ async function createTestRouter() {
   });
 }
 
+async function mountWithRouter(props: Partial<{ registerId: string; conceptId: string; formats: string[] }> = {}) {
+  const router = await createTestRouter();
+  return mount(FormatDownloads, {
+    global: { plugins: [createPinia(), router] },
+    props: { registerId: 'test', conceptId: '1', formats: [], ...props },
+  });
+}
+
 describe('FormatDownloads', () => {
-  it('renders download links for known formats', async () => {
-    const pinia = createPinia();
-    setActivePinia(pinia);
-    const router = await createTestRouter();
-    const wrapper = mount(FormatDownloads, {
-      global: { plugins: [pinia, router] },
-      props: { registerId: 'test', conceptId: '3.1.1.1', formats: ['ttl', 'jsonld'] },
-    });
+  beforeEach(() => {
+    (import.meta.env as any).BASE_URL = '/';
+  });
+
+  it('renders download links for known per-concept formats', async () => {
+    const wrapper = await mountWithRouter({ conceptId: '3.1.1.1', formats: ['ttl', 'jsonld'] });
     expect(wrapper.text()).toContain('Downloads');
-    expect(wrapper.text()).toContain('Turtle RDF');
+    expect(wrapper.text()).toContain('Turtle');
     expect(wrapper.text()).toContain('JSON-LD');
   });
 
-  it('generates correct URLs', async () => {
-    const pinia = createPinia();
-    setActivePinia(pinia);
-    const router = await createTestRouter();
-    const wrapper = mount(FormatDownloads, {
-      global: { plugins: [pinia, router] },
-      props: { registerId: 'test', conceptId: '3.1.1.1', formats: ['ttl'] },
-    });
-    const link = wrapper.find('a');
-    expect(link.attributes('href')).toBe('/data/test/concepts/3.1.1.1.ttl');
+  it('generates URLs rooted at import.meta.env.BASE_URL', async () => {
+    const wrapper = await mountWithRouter({ conceptId: '3.1.1.1', formats: ['ttl'] });
+    expect(wrapper.find('a').attributes('href')).toBe('/data/test/concepts/3.1.1.1.ttl');
+  });
+
+  it('prefixes URLs with BASE_URL on subpath deployments', async () => {
+    (import.meta.env as any).BASE_URL = '/iso-10303-2-vocab/';
+    const wrapper = await mountWithRouter({ conceptId: '3.1.1.1', formats: ['ttl'] });
+    expect(wrapper.find('a').attributes('href')).toBe('/iso-10303-2-vocab/data/test/concepts/3.1.1.1.ttl');
+  });
+
+  it('strips trailing slashes from BASE_URL before joining', async () => {
+    (import.meta.env as any).BASE_URL = '/foo///';
+    const wrapper = await mountWithRouter({ conceptId: '3.1.1.1', formats: ['ttl'] });
+    expect(wrapper.find('a').attributes('href')).toBe('/foo/data/test/concepts/3.1.1.1.ttl');
   });
 
   it('filters unknown formats', async () => {
-    const pinia = createPinia();
-    setActivePinia(pinia);
-    const router = await createTestRouter();
-    const wrapper = mount(FormatDownloads, {
-      global: { plugins: [pinia, router] },
-      props: { registerId: 'test', conceptId: '1', formats: ['ttl', 'unknown'] },
-    });
-    const links = wrapper.findAll('a');
-    expect(links.length).toBe(1);
+    const wrapper = await mountWithRouter({ conceptId: '1', formats: ['ttl', 'unknown'] });
+    expect(wrapper.findAll('a').length).toBe(1);
+  });
+
+  it('filters aggregate-only formats (e.g. TBX) out of per-concept downloads', async () => {
+    const wrapper = await mountWithRouter({ conceptId: '1', formats: ['ttl', 'tbx', 'jsonl'] });
+    const linkLabels = wrapper.findAll('a').map(a => a.text());
+    expect(linkLabels.some(l => l.includes('Turtle'))).toBe(true);
+    expect(linkLabels.some(l => l.includes('TBX'))).toBe(false);
+    expect(linkLabels.some(l => l.includes('JSON-Lines'))).toBe(false);
   });
 
   it('renders nothing when all formats are unknown', async () => {
-    const pinia = createPinia();
-    setActivePinia(pinia);
-    const router = await createTestRouter();
-    const wrapper = mount(FormatDownloads, {
-      global: { plugins: [pinia, router] },
-      props: { registerId: 'test', conceptId: '1', formats: ['unknown'] },
-    });
+    const wrapper = await mountWithRouter({ formats: ['unknown'] });
     expect(wrapper.find('a').exists()).toBe(false);
   });
 
   it('renders nothing when formats array is empty', async () => {
-    const pinia = createPinia();
-    setActivePinia(pinia);
-    const router = await createTestRouter();
-    const wrapper = mount(FormatDownloads, {
-      global: { plugins: [pinia, router] },
-      props: { registerId: 'test', conceptId: '1', formats: [] },
-    });
+    const wrapper = await mountWithRouter({ formats: [] });
     expect(wrapper.find('a').exists()).toBe(false);
   });
 
-  it('sets download attribute on links', async () => {
-    const pinia = createPinia();
-    setActivePinia(pinia);
-    const router = await createTestRouter();
-    const wrapper = mount(FormatDownloads, {
-      global: { plugins: [pinia, router] },
-      props: { registerId: 'test', conceptId: '3.1.1.1', formats: ['jsonld'] },
-    });
-    const link = wrapper.find('a');
-    expect(link.attributes('download')).toBe('3.1.1.1.jsonld');
-  });
-
-  it('shows TBX-XML format', async () => {
-    const pinia = createPinia();
-    setActivePinia(pinia);
-    const router = await createTestRouter();
-    const wrapper = mount(FormatDownloads, {
-      global: { plugins: [pinia, router] },
-      props: { registerId: 'test', conceptId: '1', formats: ['tbx'] },
-    });
-    expect(wrapper.text()).toContain('TBX-XML');
+  it('sets download attribute to bare filename (no path)', async () => {
+    const wrapper = await mountWithRouter({ conceptId: '3.1.1.1', formats: ['jsonld'] });
+    expect(wrapper.find('a').attributes('download')).toBe('3.1.1.1.jsonld');
   });
 });

package/src/__tests__/markdown-lite.test.ts

@@ -40,6 +40,25 @@ describe('renderMarkdown', () => {
     expect(result).toContain('>label</a>');
   });
 
+  it('strips dangerous schemes from markdown links (XSS defense)', () => {
+    const out1 = renderMarkdown('[click](javascript:alert(1))');
+    expect(out1).not.toContain('javascript:');
+    expect(out1).not.toContain('<a ');
+
+    const out2 = renderMarkdown('[x](data:text/html,<script>alert(1)</script>)');
+    expect(out2).not.toContain('data:');
+    expect(out2).not.toContain('<script');
+
+    const out3 = renderMarkdown('[x](vbscript:msgbox(1))');
+    expect(out3).not.toContain('vbscript:');
+  });
+
+  it('still emits rel="noopener" on safe external links', () => {
+    const out = renderMarkdown('[link](https://example.com)');
+    expect(out).toContain('rel="noopener"');
+    expect(out).toContain('target="_blank"');
+  });
+
   it('renders unordered lists', () => {
     const result = renderMarkdown('- one\n- two');
     expect(result).toContain('<ul>');

package/src/__tests__/perf/bundle-layout.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const DIST_DIR = 'dist';
+const ASSETS_DIR = join(DIST_DIR, 'assets');
+
+function distExists(): boolean {
+  return existsSync(ASSETS_DIR);
+}
+
+function readAsset(name: string): string {
+  return readFileSync(join(ASSETS_DIR, name), 'utf8');
+}
+
+function listJsAssets(): string[] {
+  return readdirSync(ASSETS_DIR).filter(f => f.endsWith('.js'));
+}
+
+const MAIN_CHUNK_RE = /^index-[^/]*\.js$/;
+const CONCEPT_CHUNK_RE = /^ConceptView-[^/]*\.js$/;
+
+describe.skipIf(!distExists())('bundle: RDF serializer stays out of main chunk', () => {
+  it('the main index-* chunk does not embed the RDF emitter', () => {
+    const mainChunks = listJsAssets().filter(f => MAIN_CHUNK_RE.test(f));
+    expect(mainChunks.length).toBeGreaterThan(0);
+
+    for (const chunk of mainChunks) {
+      const text = readAsset(chunk);
+      expect(text, `${chunk} should not embed use-rdf-document`).not.toMatch(/use-rdf-document/);
+      expect(text, `${chunk} should not emit skosxl:literalForm literals`).not.toMatch(/skosxl:literalForm/);
+    }
+  });
+
+  it('the ConceptView chunk DOES contain the RDF emitter', () => {
+    const conceptChunks = listJsAssets().filter(f => CONCEPT_CHUNK_RE.test(f));
+    expect(conceptChunks.length).toBeGreaterThan(0);
+
+    const merged = conceptChunks.map(readAsset).join('\n');
+    expect(merged).toMatch(/skosxl:literalForm/);
+  });
+
+  it('no chunk emits the legacy `xl:` prefix', () => {
+    for (const chunk of listJsAssets()) {
+      const text = readAsset(chunk);
+      expect(text, `${chunk} should not contain the legacy xl: prefix`).not.toMatch(/\bxl:prefLabel/);
+      expect(text, `${chunk} should not contain the legacy xl:altLabel/`).not.toMatch(/\bxl:altLabel/);
+    }
+  });
+});

package/src/__tests__/perf/serialization-perf.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest';
+import { Concept } from 'glossarist';
+import { emitConceptGraph } from '../../components/concept-rdf/concept-emitter';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { writeJsonLd } from '../../components/concept-rdf/jsonld-writer';
+import type { ConceptFixture } from '../__fixtures__/concepts';
+import { CONCEPT_FIXTURES } from '../__fixtures__/concepts';
+
+const BASE = 'https://glossarist.org/fixtures/perf';
+const TARGET_CONCEPT_COUNT = 500;
+const SCALE_CONCEPT_COUNT = 10_000;
+const TIME_BUDGET_MS = 2000;
+const SCALE_TIME_BUDGET_MS = 15_000;
+
+function makeConcepts(n: number): { uri: string; concept: Concept }[] {
+  const fixtures = CONCEPT_FIXTURES;
+  const out: { uri: string; concept: Concept }[] = [];
+  for (let i = 0; i < n; i++) {
+    const tpl: ConceptFixture = fixtures[i % fixtures.length];
+    const id = `${i + 1}`;
+    const concept = Concept.fromJSON({
+      id,
+      uri: `${BASE}/${id}`,
+      status: 'valid',
+      localizations: {
+        eng: {
+          language_code: 'eng',
+          entry_status: 'valid',
+          terms: [{ type: 'expression', designation: `${tpl.name} concept ${id}`, normative_status: 'preferred' }],
+          definition: [{ content: `Definition for ${tpl.name} #${id}.` }],
+        },
+      },
+    });
+    out.push({ uri: `${BASE}/${id}`, concept });
+  }
+  return out;
+}
+
+describe('Layer 7 — serialization performance regression', () => {
+  it(`emits Turtle for ${TARGET_CONCEPT_COUNT} concepts under ${TIME_BUDGET_MS}ms`, () => {
+    const concepts = makeConcepts(TARGET_CONCEPT_COUNT);
+
+    const start = performance.now();
+    for (const { concept, uri } of concepts) {
+      const { graph } = emitConceptGraph(concept, uri);
+      writeTurtle(graph);
+    }
+    const elapsed = performance.now() - start;
+
+    // eslint-disable-next-line no-console
+    console.log(`Layer 7 perf: emitted ${TARGET_CONCEPT_COUNT} concepts to Turtle in ${elapsed.toFixed(0)}ms`);
+    expect(elapsed).toBeLessThan(TIME_BUDGET_MS);
+  });
+
+  it(`emits JSON-LD for ${TARGET_CONCEPT_COUNT} concepts under ${TIME_BUDGET_MS}ms`, () => {
+    const concepts = makeConcepts(TARGET_CONCEPT_COUNT);
+
+    const start = performance.now();
+    for (const { concept, uri } of concepts) {
+      const { graph } = emitConceptGraph(concept, uri);
+      writeJsonLd(graph);
+    }
+    const elapsed = performance.now() - start;
+
+    // eslint-disable-next-line no-console
+    console.log(`Layer 7 perf: emitted ${TARGET_CONCEPT_COUNT} concepts to JSON-LD in ${elapsed.toFixed(0)}ms`);
+    expect(elapsed).toBeLessThan(TIME_BUDGET_MS);
+  });
+
+  it('per-concept emit cost stays below 5ms on average', () => {
+    const concepts = makeConcepts(100);
+    const start = performance.now();
+    for (const { concept, uri } of concepts) {
+      const { graph } = emitConceptGraph(concept, uri);
+      writeTurtle(graph);
+    }
+    const elapsed = performance.now() - start;
+    const perConcept = elapsed / 100;
+    expect(perConcept).toBeLessThan(5);
+  });
+});
+
+describe('Layer 7 — scale stress (P4: 10 000 concepts)', () => {
+  it(`emits ${SCALE_CONCEPT_COUNT} concepts to Turtle under ${SCALE_TIME_BUDGET_MS}ms`, () => {
+    const concepts = makeConcepts(SCALE_CONCEPT_COUNT);
+    const start = performance.now();
+    for (const { concept, uri } of concepts) {
+      const { graph } = emitConceptGraph(concept, uri);
+      writeTurtle(graph);
+    }
+    const elapsed = performance.now() - start;
+    // eslint-disable-next-line no-console
+    console.log(`P4 scale: emitted ${SCALE_CONCEPT_COUNT} concepts to Turtle in ${elapsed.toFixed(0)}ms`);
+    expect(elapsed).toBeLessThan(SCALE_TIME_BUDGET_MS);
+  });
+
+  it('emission cost scales linearly (slope within 3x of the 500-concept baseline)', () => {
+    const small = makeConcepts(500);
+    const large = makeConcepts(SCALE_CONCEPT_COUNT);
+
+    const tSmall = timeTurtle(small);
+    const tLarge = timeTurtle(large);
+    const ratio = tLarge / tSmall;
+    const expectedRatio = SCALE_CONCEPT_COUNT / 500;
+    const overhead = ratio / expectedRatio;
+
+    // eslint-disable-next-line no-console
+    console.log(`P4 scale: 500→${SCALE_CONCEPT_COUNT} ratio=${ratio.toFixed(1)}x (expected ~${expectedRatio}x, overhead=${overhead.toFixed(2)}x)`);
+
+    expect(overhead).toBeLessThan(3);
+  });
+});
+
+function timeTurtle(concepts: { concept: Concept; uri: string }[]): number {
+  const start = performance.now();
+  for (const { concept, uri } of concepts) {
+    const { graph } = emitConceptGraph(concept, uri);
+    writeTurtle(graph);
+  }
+  return performance.now() - start;
+}

package/src/__tests__/scripts/agents-turtle.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { buildAgentsTurtle } from '../../../scripts/lib/agents-turtle.mjs';
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+const FOAF = 'http://xmlns.com/foaf/0.1/';
+const PROV = 'http://www.w3.org/ns/prov#';
+const DCTERMS = 'http://purl.org/dc/terms/';
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+
+describe('buildAgentsTurtle (mjs)', () => {
+  it('parses without errors', () => {
+    const ttl = buildAgentsTurtle([{ name: 'Ada Lovelace' }]);
+    const store = parse(ttl);
+    expect(store.size).toBeGreaterThan(0);
+  });
+
+  it('types each person as foaf:Person, prov:Person, prov:Agent', () => {
+    const ttl = buildAgentsTurtle([{ name: 'Ada Lovelace' }]);
+    const store = parse(ttl);
+    const types = store.getObjects('https://glossarist.org/agent/ada-lovelace', RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${FOAF}Person`);
+    expect(types).toContain(`${PROV}Person`);
+    expect(types).toContain(`${PROV}Agent`);
+  });
+
+  it('records name, mailto mbox, role, and seeAlso', () => {
+    const ttl = buildAgentsTurtle([
+      { name: 'Ada Lovelace', email: 'ada@example.org', role: 'Editor', url: 'https://example.org/ada' },
+    ]);
+    const store = parse(ttl);
+    const iri = 'https://glossarist.org/agent/ada-lovelace';
+    expect(store.getObjects(iri, `${FOAF}name`, null).map(q => q.value)).toContain('Ada Lovelace');
+    expect(store.getObjects(iri, `${FOAF}mbox`, null).map(q => q.value)).toContain('mailto:ada@example.org');
+    expect(store.getObjects(iri, `${DCTERMS}description`, null).map(q => q.value)).toContain('Editor');
+    expect(store.getObjects(iri, 'http://www.w3.org/2000/01/rdf-schema#seeAlso', null).map(q => q.value)).toContain('https://example.org/ada');
+  });
+
+  it('creates a single prov:Organization per unique organization', () => {
+    const ttl = buildAgentsTurtle([
+      { name: 'Alice', organization: 'ISO' },
+      { name: 'Bob',   organization: 'ISO' },
+    ]);
+    const store = parse(ttl);
+    const types = store.getObjects('https://glossarist.org/org/iso', RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${FOAF}Organization`);
+    expect(types).toContain(`${PROV}Organization`);
+  });
+
+  it('emits only prefix declarations for an empty input', () => {
+    const ttl = buildAgentsTurtle([]);
+    expect(ttl).toContain('@prefix foaf:');
+    expect(ttl).not.toContain('<https://glossarist.org/agent/');
+  });
+});

package/src/__tests__/scripts/bibliography-turtle.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { buildBibliographyTurtle } from '../../../scripts/lib/bibliography-turtle.mjs';
+
+const FOAF = 'http://xmlns.com/foaf/0.1/';
+const DCTERMS = 'http://purl.org/dc/terms/';
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+describe('buildBibliographyTurtle (mjs)', () => {
+  it('parses without errors', () => {
+    const ttl = buildBibliographyTurtle('iso-geodetic', { iso704: { reference: 'ISO 704' } });
+    const store = parse(ttl);
+    expect(store.size).toBeGreaterThan(0);
+  });
+
+  it('types each entry as dcterms:BibliographicResource', () => {
+    const ttl = buildBibliographyTurtle('iso-geodetic', { iso704: { reference: 'ISO 704' } });
+    const store = parse(ttl);
+    const types = store.getObjects('https://glossarist.org/iso-geodetic/bib/iso704', RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${DCTERMS}BibliographicResource`);
+  });
+
+  it('emits identifier, bibliographicCitation, and title', () => {
+    const ttl = buildBibliographyTurtle('iso-geodetic', {
+      iso704: { reference: 'ISO 704', title: 'Terminology work — Principles and methods' },
+    });
+    const store = parse(ttl);
+    const iri = 'https://glossarist.org/iso-geodetic/bib/iso704';
+    expect(store.getObjects(iri, `${DCTERMS}identifier`, null).map(q => q.value)).toContain('iso704');
+    expect(store.getObjects(iri, `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('ISO 704');
+    expect(store.getObjects(iri, `${DCTERMS}title`, null).map(q => q.value)).toContain('Terminology work — Principles and methods');
+  });
+
+  it('emits foaf:page when link is provided', () => {
+    const ttl = buildBibliographyTurtle('iso-geodetic', {
+      ref: { reference: 'X', link: 'https://example.org/x' },
+    });
+    const store = parse(ttl);
+    const iri = 'https://glossarist.org/iso-geodetic/bib/ref';
+    expect(store.getObjects(iri, `${FOAF}page`, null).map(q => q.value)).toContain('https://example.org/x');
+  });
+
+  it('emits one resource per bibliography entry', () => {
+    const ttl = buildBibliographyTurtle('iso-geodetic', {
+      a: { reference: 'A' },
+      b: { reference: 'B' },
+    });
+    const store = parse(ttl);
+    expect(store.getObjects('https://glossarist.org/iso-geodetic/bib/a', `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('A');
+    expect(store.getObjects('https://glossarist.org/iso-geodetic/bib/b', `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('B');
+  });
+});