@glossarist/concept-browser 0.7.51 → 0.7.52

package/src/__tests__/scripts/build-activity-turtle.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { buildActivityTurtle } from '../../../scripts/lib/build-activity-turtle.mjs';
+
+function makeInput(overrides: any = {}): any {
+  return {
+    runId: '2026-06-28T12-00-00Z',
+    startedAt: '2026-06-28T12:00:00Z',
+    endedAt: '2026-06-28T12:05:00Z',
+    gitSha: 'abc1234',
+    gitBranch: 'main',
+    toolId: 'concept-browser',
+    toolVersion: '0.7.51',
+    datasetRegisters: ['iso-geodetic'],
+    conceptCount: 1234,
+    associatedAgentIri: 'https://glossarist.org/agent/ci-bot',
+    ...overrides,
+  };
+}
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+const ACTIVITY_IRI = (runId: string) => `https://glossarist.org/activity/build/${runId}`;
+const expand = (v: string): string => {
+  if (v.startsWith('prov:'))    return `http://www.w3.org/ns/prov#${v.slice(5)}`;
+  if (v.startsWith('dcterms:')) return `http://purl.org/dc/terms/${v.slice(8)}`;
+  if (v.startsWith('rdf:'))     return `http://www.w3.org/1999/02/22-rdf-syntax-ns#${v.slice(4)}`;
+  if (v.startsWith('xsd:'))     return `http://www.w3.org/2001/XMLSchema#${v.slice(4)}`;
+  if (v.startsWith('foaf:'))    return `http://xmlns.com/foaf/0.1/${v.slice(5)}`;
+  return v;
+};
+
+describe('buildActivityTurtle (mjs)', () => {
+  it('parses without errors', () => {
+    const ttl = buildActivityTurtle(makeInput());
+    const store = parse(ttl);
+    expect(store.size).toBeGreaterThan(0);
+  });
+
+  it('types the activity as prov:Activity', () => {
+    const input = makeInput();
+    const store = parse(buildActivityTurtle(input));
+    const types = store.getObjects(ACTIVITY_IRI(input.runId), expand('rdf:type'), null).map(q => q.value);
+    expect(types).toContain(expand('prov:Activity'));
+  });
+
+  it('records git commit and tool as prov:used', () => {
+    const input = makeInput();
+    const store = parse(buildActivityTurtle(input));
+    const used = store.getObjects(ACTIVITY_IRI(input.runId), expand('prov:used'), null).map(q => q.value);
+    expect(used).toContain(`https://glossarist.org/commit/${input.gitSha}`);
+    expect(used).toContain(`https://glossarist.org/tool/${input.toolId}/${input.toolVersion}`);
+  });
+
+  it('references every dataset register via prov:used', () => {
+    const input = makeInput({ datasetRegisters: ['a', 'b', 'c'] });
+    const store = parse(buildActivityTurtle(input));
+    const used = store.getObjects(ACTIVITY_IRI(input.runId), expand('prov:used'), null).map(q => q.value);
+    for (const r of input.datasetRegisters) {
+      expect(used).toContain(`https://glossarist.org/${r}/`);
+    }
+  });
+
+  it('associates the CI agent when provided', () => {
+    const input = makeInput();
+    const store = parse(buildActivityTurtle(input));
+    const agents = store.getObjects(ACTIVITY_IRI(input.runId), expand('prov:wasAssociatedWith'), null).map(q => q.value);
+    expect(agents).toContain(input.associatedAgentIri);
+  });
+});

package/src/__tests__/scripts/build-cache.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { rmSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { BuildCache } from '../../../scripts/lib/build-cache.mjs';
+
+const SUITE_DIR = join(tmpdir(), `build-cache-${process.pid}-${Date.now()}`);
+
+beforeEach(() => {
+  mkdirSync(SUITE_DIR, { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(SUITE_DIR, { recursive: true, force: true });
+});
+
+describe('BuildCache', () => {
+  it('returns null for a missing key', async () => {
+    const cache = new BuildCache(SUITE_DIR);
+    expect(await cache.get('missing')).toBeNull();
+  });
+
+  it('round-trips a value through set/get', async () => {
+    const cache = new BuildCache(SUITE_DIR);
+    await cache.set('concept-3.1.1', { ttl: '@prefix' }, 'aaa');
+    const entry = await cache.get('concept-3.1.1');
+    expect(entry?.value).toEqual({ ttl: '@prefix' });
+    expect(entry?.hash).toBe('aaa');
+  });
+
+  it('readThrough invokes the producer on a miss', async () => {
+    const cache = new BuildCache(SUITE_DIR);
+    let calls = 0;
+    const { value, hit } = await cache.readThrough('k', 'h1', async () => {
+      calls++;
+      return { ok: true };
+    });
+    expect(hit).toBe(false);
+    expect(calls).toBe(1);
+    expect(value).toEqual({ ok: true });
+  });
+
+  it('readThrough skips the producer on a hit', async () => {
+    const cache = new BuildCache(SUITE_DIR);
+    await cache.set('k', { ok: true }, 'h1');
+    let calls = 0;
+    const { value, hit } = await cache.readThrough('k', 'h1', async () => {
+      calls++;
+      return { ok: false };
+    });
+    expect(hit).toBe(true);
+    expect(calls).toBe(0);
+    expect(value).toEqual({ ok: true });
+  });
+
+  it('readThrough re-invokes the producer when the hash differs', async () => {
+    const cache = new BuildCache(SUITE_DIR);
+    await cache.set('k', 'old', 'h1');
+    const { value, hit } = await cache.readThrough('k', 'h2', async () => 'new');
+    expect(hit).toBe(false);
+    expect(value).toBe('new');
+  });
+
+  it('hash is stable for the same input', () => {
+    expect(BuildCache.hash('hello')).toBe(BuildCache.hash('hello'));
+  });
+
+  it('hash differs for different inputs', () => {
+    expect(BuildCache.hash('hello')).not.toBe(BuildCache.hash('world'));
+  });
+
+  it('sanitizes unsafe key characters in the on-disk path', async () => {
+    const cache = new BuildCache(SUITE_DIR);
+    await cache.set('this/has spaces&symbols', 1, 'h');
+    const entry = await cache.get('this/has spaces&symbols');
+    expect(entry?.value).toBe(1);
+  });
+});

package/src/__tests__/scripts/build-integration.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from 'vitest';
+import { execFileSync } from 'node:child_process';
+import { Parser, Store } from 'n3';
+
+function parseTurtle(text: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(text));
+  return store;
+}
+
+function runInline(code: string): string {
+  return execFileSync('node', ['--input-type=module', '-e', code], { encoding: 'utf8' }).toString();
+}
+
+describe('WS F Layer 8 — build pipeline integration', () => {
+  it('vocab-turtle.mjs produces parseable Turtle with 7 schemes', () => {
+    const out = runInline(`import { buildVocabularyTurtle } from './scripts/lib/vocab-turtle.mjs'; console.log(buildVocabularyTurtle());`);
+    const store = parseTurtle(out);
+    const schemes = [...store].filter(q =>
+      q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' &&
+      q.object.value === 'http://www.w3.org/2004/02/skos/core#ConceptScheme',
+    );
+    expect(schemes.length).toBe(7);
+  });
+
+  it('dataset-turtle.mjs produces parseable dcat:Dataset', () => {
+    const out = runInline(`
+      import { buildDatasetTurtle } from './scripts/lib/dataset-turtle.mjs';
+      console.log(buildDatasetTurtle({
+        datasetIri: 'https://glossarist.org/test/',
+        registerId: 'test', title: 'Test', modified: '2026-06-28',
+        languages: ['eng'], distributions: [], topConceptUris: [], sections: [],
+      }));
+    `);
+    const store = parseTurtle(out);
+    const types = [...store].filter(q =>
+      q.subject.value === 'https://glossarist.org/test/' &&
+      q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type',
+    ).map(q => q.object.value);
+    expect(types).toContain('http://www.w3.org/ns/dcat#Dataset');
+    expect(types).toContain('http://www.w3.org/2004/02/skos/core#ConceptScheme');
+  });
+
+  it('build-activity-turtle.mjs produces parseable prov:Activity', () => {
+    const out = runInline(`
+      import { buildActivityTurtle } from './scripts/lib/build-activity-turtle.mjs';
+      console.log(buildActivityTurtle({
+        runId: 'test', startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:05:00Z',
+        toolId: 'cb', toolVersion: '0.7.52', datasetRegisters: [], conceptCount: 0,
+      }));
+    `);
+    const store = parseTurtle(out);
+    const activities = [...store].filter(q =>
+      q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' &&
+      q.object.value === 'http://www.w3.org/ns/prov#Activity',
+    );
+    expect(activities.length).toBe(1);
+  });
+
+  it('agents-turtle.mjs produces parseable foaf:Person', () => {
+    const out = runInline(`
+      import { buildAgentsTurtle } from './scripts/lib/agents-turtle.mjs';
+      console.log(buildAgentsTurtle([{ name: 'Ada Lovelace', role: 'Editor', organization: 'Royal Society' }]));
+    `);
+    const store = parseTurtle(out);
+    const persons = [...store].filter(q =>
+      q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' &&
+      q.object.value === 'http://xmlns.com/foaf/0.1/Person',
+    );
+    expect(persons.length).toBe(1);
+  });
+
+  it('bibliography-turtle.mjs produces parseable dcterms:BibliographicResource', () => {
+    const out = runInline(`
+      import { buildBibliographyTurtle } from './scripts/lib/bibliography-turtle.mjs';
+      console.log(buildBibliographyTurtle('test', { iso704: { reference: 'ISO 704' } }));
+    `);
+    const store = parseTurtle(out);
+    const bibs = [...store].filter(q =>
+      q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' &&
+      q.object.value === 'http://purl.org/dc/terms/BibliographicResource',
+    );
+    expect(bibs.length).toBe(1);
+  });
+
+  it('version-turtle.mjs produces parseable prov:Entity chain', () => {
+    const out = runInline(`
+      import { buildVersionHistoryTurtle } from './scripts/lib/version-turtle.mjs';
+      console.log(buildVersionHistoryTurtle({
+        registerId: 'test', datasetIri: 'https://glossarist.org/test/',
+        versions: [
+          { version: '1.0', generatedAt: '2024-01-01T00:00:00Z' },
+          { version: '1.1', generatedAt: '2024-06-01T00:00:00Z' },
+        ],
+      }));
+    `);
+    const store = parseTurtle(out);
+    const versions = [...store].filter(q =>
+      q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' &&
+      q.object.value === 'http://www.w3.org/ns/prov#Entity',
+    );
+    expect(versions.length).toBe(2);
+
+    const wasRevision = store.getObjects(
+      'https://glossarist.org/test/versions/1.1',
+      'http://www.w3.org/ns/prov#wasRevisionOf',
+      null,
+    ).map(q => q.value);
+    expect(wasRevision).toContain('https://glossarist.org/test/versions/1.0');
+  });
+
+  it('all six emitters produce parseable output in a single subprocess', () => {
+    const out = runInline(`
+      import { buildVocabularyTurtle } from './scripts/lib/vocab-turtle.mjs';
+      import { buildDatasetTurtle } from './scripts/lib/dataset-turtle.mjs';
+      import { buildActivityTurtle } from './scripts/lib/build-activity-turtle.mjs';
+      import { buildAgentsTurtle } from './scripts/lib/agents-turtle.mjs';
+      import { buildBibliographyTurtle } from './scripts/lib/bibliography-turtle.mjs';
+      import { buildVersionHistoryTurtle } from './scripts/lib/version-turtle.mjs';
+      const parts = [
+        buildVocabularyTurtle(),
+        buildDatasetTurtle({ datasetIri: 'https://glossarist.org/test/', registerId: 'test', title: 't', modified: '2026-01-01', languages: ['eng'], distributions: [], topConceptUris: [], sections: [] }),
+        buildActivityTurtle({ runId: 'r', startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:05:00Z', toolId: 'cb', toolVersion: '0', datasetRegisters: [], conceptCount: 0 }),
+        buildAgentsTurtle([{ name: 'Ada' }]),
+        buildBibliographyTurtle('test', { x: { reference: 'X' } }),
+        buildVersionHistoryTurtle({ registerId: 't', datasetIri: 'https://glossarist.org/t/', versions: [{ version: '1', generatedAt: '2026-01-01' }] }),
+      ];
+      console.log(parts.join('\\n'));
+    `);
+    const store = parseTurtle(out);
+    expect(store.size).toBeGreaterThan(100);
+  });
+});

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

@@ -0,0 +1,94 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { buildDatasetTurtle } from '../../../scripts/lib/dataset-turtle.mjs';
+
+const BASE = 'https://glossarist.org/dataset';
+
+function makeInput(overrides: Record<string, any> = {}): any {
+  return {
+    datasetIri: `${BASE}/test`,
+    registerId: 'test',
+    title: 'Test Glossary',
+    description: 'A test dataset.',
+    modified: '2026-06-28',
+    languages: ['eng', 'fra'],
+    distributions: [
+      {
+        id: 'test-ttl',
+        title: 'Turtle distribution',
+        mediaType: 'text/turtle',
+        downloadUrl: 'https://glossarist.org/data/test.ttl',
+        byteSize: 12345,
+      },
+    ],
+    topConceptUris: [`${BASE}/test/concept/1`, `${BASE}/test/concept/2`],
+    sections: [
+      {
+        collectionIri: `${BASE}/test/section/3-1`,
+        title: 'Geodetic concepts',
+        memberUris: [`${BASE}/test/concept/1`],
+      },
+    ],
+    ...overrides,
+  };
+}
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+const expand = (v: string): string => {
+  if (v.startsWith('dcat:'))    return `http://www.w3.org/ns/dcat#${v.slice(5)}`;
+  if (v.startsWith('skos:'))    return `http://www.w3.org/2004/02/skos/core#${v.slice(5)}`;
+  if (v.startsWith('dcterms:')) return `http://purl.org/dc/terms/${v.slice(8)}`;
+  if (v.startsWith('rdf:'))     return `http://www.w3.org/1999/02/22-rdf-syntax-ns#${v.slice(4)}`;
+  if (v.startsWith('prov:'))    return `http://www.w3.org/ns/prov#${v.slice(5)}`;
+  return v;
+};
+
+describe('buildDatasetTurtle (mjs)', () => {
+  it('parses without errors and produces a non-empty graph', () => {
+    const ttl = buildDatasetTurtle(makeInput());
+    const store = parse(ttl);
+    expect(store.size).toBeGreaterThan(0);
+  });
+
+  it('types the dataset as dcat:Dataset and skos:ConceptScheme', () => {
+    const input = makeInput();
+    const store = parse(buildDatasetTurtle(input));
+    const types = store.getObjects(input.datasetIri, expand('rdf:type'), null).map(q => q.value);
+    expect(types).toContain(expand('dcat:Dataset'));
+    expect(types).toContain(expand('skos:ConceptScheme'));
+  });
+
+  it('emits a dcat:Distribution blank per distribution', () => {
+    const input = makeInput();
+    const store = parse(buildDatasetTurtle(input));
+    const dists = store.getObjects(input.datasetIri, expand('dcat:distribution'), null);
+    expect(dists.length).toBe(1);
+    const mediaTypes = store.getObjects(dists[0], expand('dcat:mediaType'), null).map(q => q.value);
+    expect(mediaTypes).toContain('text/turtle');
+    const byteSizes = store.getObjects(dists[0], expand('dcat:byteSize'), null).map(q => q.value);
+    expect(byteSizes).toContain('12345');
+  });
+
+  it('emits skos:Collection per section with skos:member entries', () => {
+    const input = makeInput();
+    const store = parse(buildDatasetTurtle(input));
+    const section = input.sections[0];
+    const types = store.getObjects(section.collectionIri, expand('rdf:type'), null).map(q => q.value);
+    expect(types).toContain(expand('skos:Collection'));
+    const members = store.getObjects(section.collectionIri, expand('skos:member'), null).map(q => q.value);
+    expect(members).toContain(`${BASE}/test/concept/1`);
+  });
+
+  it('escapes double-quotes and backslashes in titles', () => {
+    const input = makeInput({ title: 'has "quotes" and back\\slash' });
+    const store = parse(buildDatasetTurtle(input));
+    const titles = store.getObjects(input.datasetIri, expand('dcterms:title'), null).map(q => q.value);
+    expect(titles).toContain('has "quotes" and back\\slash');
+  });
+});

package/src/__tests__/scripts/normalize-yaml.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, readFileSync, rmSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { normalizeYaml } from '../../../scripts/normalize-yaml.mjs';
+
+const NFC_STRING = 'café';
+const NON_NFC_STRING = 'café';
+
+function makeTempDataset() {
+  const dir = mkdtempSync(join(tmpdir(), 'glossarist-nfc-'));
+  return dir;
+}
+
+describe('normalizeYaml', () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = makeTempDataset();
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('detects non-NFC YAML files in check mode without modifying them', () => {
+    const file = join(dir, 'concept.yaml');
+    writeFileSync(file, `term: "${NON_NFC_STRING}"\n`, 'utf8');
+
+    const { checked, nonNfc, fixed, check } = normalizeYaml({ root: dir, check: true, paths: ['.'] });
+
+    expect(checked).toBe(1);
+    expect(nonNfc).toBe(1);
+    expect(fixed).toHaveLength(1);
+    expect(check).toBe(true);
+
+    const after = readFileSync(file, 'utf8');
+    expect(after).toContain(NON_NFC_STRING);
+    expect(after).not.toContain(NFC_STRING);
+  });
+
+  it('normalizes non-NFC YAML files in fix mode', () => {
+    const file = join(dir, 'concept.yaml');
+    writeFileSync(file, `term: "${NON_NFC_STRING}"\n`, 'utf8');
+
+    const { checked, nonNfc, fixed } = normalizeYaml({ root: dir, check: false, paths: ['.'] });
+
+    expect(checked).toBe(1);
+    expect(nonNfc).toBe(1);
+    expect(fixed).toHaveLength(1);
+
+    const after = readFileSync(file, 'utf8');
+    expect(after).toContain(NFC_STRING);
+    expect(after).not.toContain(NON_NFC_STRING);
+  });
+
+  it('passes through already-NFC files without changes', () => {
+    writeFileSync(join(dir, 'a.yaml'), `term: "${NFC_STRING}"\n`, 'utf8');
+    writeFileSync(join(dir, 'b.yaml'), `term: "hello"\n`, 'utf8');
+
+    const { checked, nonNfc, fixed } = normalizeYaml({ root: dir, check: true, paths: ['.'] });
+
+    expect(checked).toBe(2);
+    expect(nonNfc).toBe(0);
+    expect(fixed).toHaveLength(0);
+  });
+
+  it('walks subdirectories recursively', () => {
+    const subDir = join(dir, 'concepts', 'sub');
+    mkdirSync(subDir, { recursive: true });
+    writeFileSync(join(subDir, 'deep.yaml'), `text: "${NON_NFC_STRING}"\n`, 'utf8');
+    writeFileSync(join(dir, 'top.yaml'), `text: "ok"\n`, 'utf8');
+
+    const { checked, nonNfc } = normalizeYaml({ root: dir, check: true, paths: ['.'] });
+
+    expect(checked).toBe(2);
+    expect(nonNfc).toBe(1);
+  });
+
+  it('skips node_modules and dist directories', () => {
+    mkdirSync(join(dir, 'node_modules'), { recursive: true });
+    mkdirSync(join(dir, 'dist'), { recursive: true });
+    writeFileSync(join(dir, 'node_modules', 'dep.yaml'), `x: "${NON_NFC_STRING}"\n`, 'utf8');
+    writeFileSync(join(dir, 'dist', 'out.yaml'), `x: "${NON_NFC_STRING}"\n`, 'utf8');
+    writeFileSync(join(dir, 'good.yaml'), `x: "${NFC_STRING}"\n`, 'utf8');
+
+    const { checked, nonNfc } = normalizeYaml({ root: dir, check: true, paths: ['.'] });
+
+    expect(checked).toBe(1);
+    expect(nonNfc).toBe(0);
+  });
+
+  it('handles empty or nonexistent search directories gracefully', () => {
+    const result = normalizeYaml({ root: '/nonexistent/path', check: true });
+    expect(result.checked).toBe(0);
+    expect(result.nonNfc).toBe(0);
+  });
+});

package/src/__tests__/scripts/stryker-config.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const STRYKER_CONFIG = join(process.cwd(), 'stryker.config.mjs');
+
+describe('WS P2 — stryker mutation testing setup', () => {
+  it('ships a stryker config file', () => {
+    expect(existsSync(STRYKER_CONFIG)).toBe(true);
+  });
+
+  it('config scopes mutation to the three highest-value emitter files', () => {
+    const content = readFileSync(STRYKER_CONFIG, 'utf8');
+    expect(content).toContain('src/components/concept-rdf/concept-emitter.ts');
+    expect(content).toContain('src/components/concept-rdf/dataset-emitter.ts');
+    expect(content).toContain('src/components/concept-rdf/bibliography-emitter.ts');
+  });
+
+  it('config declares a break threshold (build fails if mutation score drops)', () => {
+    const content = readFileSync(STRYKER_CONFIG, 'utf8');
+    expect(content).toMatch(/break:\s*\d+/);
+  });
+
+  it('config uses vitest as the test runner', () => {
+    const content = readFileSync(STRYKER_CONFIG, 'utf8');
+    expect(content).toMatch(/testRunner:\s*['"]vitest['"]/);
+  });
+
+  it('package.json exposes npm run mutation:test', () => {
+    const pkg = JSON.parse(readFileSync(join(process.cwd(), 'package.json'), 'utf8'));
+    expect(pkg.scripts['mutation:test']).toMatch(/^stryker run/);
+  });
+});

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

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+import { ttlLit, ttlPrefixed, ttlIri, assertValidIri } from '../../../scripts/lib/turtle-escape.mjs';
+
+describe('D1/D2 — Turtle escaping hardening', () => {
+  describe('ttlLit', () => {
+    it('escapes backslashes and quotes', () => {
+      expect(ttlLit('has "quotes" and back\\slash')).toBe('"has \\"quotes\\" and back\\\\slash"');
+    });
+
+    it('escapes newlines, tabs, carriage returns', () => {
+      expect(ttlLit('line1\nline2\ttab\rreturn')).toBe('"line1\\nline2\\ttab\\rreturn"');
+    });
+
+    it('returns empty literal for null/undefined', () => {
+      expect(ttlLit(null)).toBe('""');
+      expect(ttlLit(undefined)).toBe('""');
+    });
+
+    it('coerces non-strings to string', () => {
+      expect(ttlLit(42)).toBe('"42"');
+    });
+  });
+
+  describe('ttlPrefixed', () => {
+    it('escapes forward slashes in local names per Turtle PN_LOCAL rules', () => {
+      expect(ttlPrefixed('gloss:status/valid')).toBe('gloss:status\\/valid');
+    });
+
+    it('passes through names without slashes unchanged', () => {
+      expect(ttlPrefixed('gloss:Concept')).toBe('gloss:Concept');
+    });
+  });
+
+  describe('assertValidIri / ttlIri', () => {
+    it('accepts a clean IRI', () => {
+      expect(assertValidIri('https://example.org/path')).toBe('https://example.org/path');
+    });
+
+    it('rejects IRIs with angle brackets', () => {
+      expect(() => assertValidIri('https://x.test/<bad>')).toThrow(/forbidden characters/);
+    });
+
+    it('rejects IRIs with double quotes', () => {
+      expect(() => assertValidIri('https://x.test/"bad"')).toThrow(/forbidden characters/);
+    });
+
+    it('rejects IRIs with spaces', () => {
+      expect(() => assertValidIri('https://x.test/bad path')).toThrow(/forbidden characters/);
+    });
+
+    it('rejects non-string IRIs', () => {
+      expect(() => assertValidIri(42)).toThrow(/expected string/);
+    });
+
+    it('ttlIri wraps a clean IRI in angle brackets', () => {
+      expect(ttlIri('https://example.org/x')).toBe('<https://example.org/x>');
+    });
+
+    it('ttlIri throws on invalid IRIs', () => {
+      expect(() => ttlIri('https://x.test/<bad>')).toThrow();
+    });
+  });
+});

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

@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { buildVersionTurtle, buildVersionHistoryTurtle } from '../../../scripts/lib/version-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 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('buildVersionTurtle (mjs)', () => {
+  it('parses without errors', () => {
+    const ttl = buildVersionTurtle({
+      registerId: 'test',
+      version: '1.0',
+      versionIri: 'https://glossarist.org/test/versions/1.0',
+      datasetIri: 'https://glossarist.org/test/',
+      generatedAt: '2026-06-28T12:00:00Z',
+    });
+    const store = parse(ttl);
+    expect(store.size).toBeGreaterThan(0);
+  });
+
+  it('types the version as prov:Entity', () => {
+    const ttl = buildVersionTurtle({
+      registerId: 'test',
+      version: '1.0',
+      versionIri: 'https://glossarist.org/test/versions/1.0',
+      datasetIri: 'https://glossarist.org/test/',
+      generatedAt: '2026-06-28T12:00:00Z',
+    });
+    const store = parse(ttl);
+    const types = store.getObjects('https://glossarist.org/test/versions/1.0', RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${PROV}Entity`);
+  });
+
+  it('emits prov:wasRevisionOf when a previous version is provided', () => {
+    const ttl = buildVersionTurtle({
+      registerId: 'test',
+      version: '1.0',
+      versionIri: 'https://glossarist.org/test/versions/1.0',
+      datasetIri: 'https://glossarist.org/test/',
+      generatedAt: '2026-06-28T12:00:00Z',
+      previousVersionIri: 'https://glossarist.org/test/versions/0.9',
+    });
+    const store = parse(ttl);
+    const prev = store.getObjects('https://glossarist.org/test/versions/1.0', `${PROV}wasRevisionOf`, null).map(q => q.value);
+    expect(prev).toContain('https://glossarist.org/test/versions/0.9');
+  });
+});
+
+describe('buildVersionHistoryTurtle (mjs)', () => {
+  it('emits a chain with revision links', () => {
+    const ttl = buildVersionHistoryTurtle({
+      registerId: 'test',
+      datasetIri: 'https://glossarist.org/test/',
+      versions: [
+        { version: '1.0', generatedAt: '2024-01-01T00:00:00Z' },
+        { version: '1.1', generatedAt: '2024-06-01T00:00:00Z' },
+      ],
+    });
+    const store = parse(ttl);
+    const iri11 = 'https://glossarist.org/test/versions/1.1';
+    const prev = store.getObjects(iri11, `${PROV}wasRevisionOf`, null).map(q => q.value);
+    expect(prev).toContain('https://glossarist.org/test/versions/1.0');
+  });
+});