@glossarist/concept-browser 0.7.66 → 0.7.68

package/scripts/process-about-pages.mjs

@@ -14,16 +14,35 @@
 //
 // Output shape: { title: string, html: string }
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
-import { join, basename, extname } from 'node:path';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, realpathSync } from 'node:fs';
+import { join, basename, extname, resolve } from 'node:path';
 import { cwd } from 'node:process';
+import { fileURLToPath } from 'node:url';
 
-const ROOT = cwd();
-const PUBLIC_PAGES = join(ROOT, 'public', 'pages');
-const DATASETS_DIR = join(ROOT, '.datasets');
-const GROUPS_CONTENT_DIR = join(ROOT, 'site-content', 'groups');
+import { loadSiteConfig } from './load-site-config.mjs';
 
-function renderMarkdown(text) {
+export function loadSiteConfigForAbout() {
+  try {
+    const { config } = loadSiteConfig([]);
+    return config;
+  } catch {
+    return null;
+  }
+}
+
+// Resolve roots at call time, not at module load — supports test
+// environments that chdir between module import and main() call.
+export function roots() {
+  const ROOT = cwd();
+  return {
+    ROOT,
+    PUBLIC_PAGES: join(ROOT, 'public', 'pages'),
+    DATASETS_DIR: join(ROOT, '.datasets'),
+    GROUPS_CONTENT_DIR: join(ROOT, 'site-content', 'groups'),
+  };
+}
+
+export function renderMarkdown(text) {
   // Minimal markdown → HTML. For production, use a real parser.
   // This handles headings, paragraphs, bold, italic, links, lists.
   const lines = text.split('\n');
@@ -65,7 +84,7 @@ function inline(text) {
     .replace(/`(.+?)`/g, '<code>$1</code>');
 }
 
-function processAboutDir(sourceDir, outputPrefix) {
+export function processAboutDir(sourceDir, outputPrefix, publicPagesDir) {
   if (!existsSync(sourceDir)) return 0;
   let count = 0;
 
@@ -104,8 +123,8 @@ function processAboutDir(sourceDir, outputPrefix) {
     }
 
     const output = { title, html };
-    mkdirSync(PUBLIC_PAGES, { recursive: true });
-    writeFileSync(join(PUBLIC_PAGES, outputName), JSON.stringify(output));
+    mkdirSync(publicPagesDir, { recursive: true });
+    writeFileSync(join(publicPagesDir, outputName), JSON.stringify(output));
     count++;
     console.log(`  Compiled: ${file} → public/pages/${outputName}`);
   }
@@ -113,20 +132,41 @@ function processAboutDir(sourceDir, outputPrefix) {
   return count;
 }
 
-function main() {
+export function main() {
+  const { ROOT, PUBLIC_PAGES, DATASETS_DIR, GROUPS_CONTENT_DIR } = roots();
   mkdirSync(PUBLIC_PAGES, { recursive: true });
   let total = 0;
 
-  // Dataset about pages
+  // Dataset about pages — discover from .datasets/<id>/about/ (fetched
+  // or copied) OR from site-config localPath overrides for datasets that
+  // aren't materialized under .datasets/.
+  const siteConfig = loadSiteConfigForAbout();
+  const localPathMap = new Map();
+  for (const ds of siteConfig?.datasets || []) {
+    if (ds.id && ds.localPath) {
+      localPathMap.set(ds.id, resolve(ROOT, ds.localPath));
+    }
+  }
+
+  const seenIds = new Set();
   if (existsSync(DATASETS_DIR)) {
     for (const dsId of readdirSync(DATASETS_DIR)) {
+      seenIds.add(dsId);
       const aboutDir = join(DATASETS_DIR, dsId, 'about');
       if (existsSync(aboutDir) && statSync(aboutDir).isDirectory()) {
         console.log(`Processing dataset: ${dsId}`);
-        total += processAboutDir(aboutDir, `dataset-${dsId}-about`);
+        total += processAboutDir(aboutDir, `dataset-${dsId}-about`, PUBLIC_PAGES);
       }
     }
   }
+  for (const [dsId, dsPath] of localPathMap) {
+    if (seenIds.has(dsId)) continue;
+    const aboutDir = join(dsPath, 'about');
+    if (existsSync(aboutDir) && statSync(aboutDir).isDirectory()) {
+      console.log(`Processing dataset (localPath): ${dsId}`);
+      total += processAboutDir(aboutDir, `dataset-${dsId}-about`, PUBLIC_PAGES);
+    }
+  }
 
   // Group about pages
   if (existsSync(GROUPS_CONTENT_DIR)) {
@@ -134,7 +174,7 @@ function main() {
       const aboutDir = join(GROUPS_CONTENT_DIR, groupId, 'about');
       if (existsSync(aboutDir) && statSync(aboutDir).isDirectory()) {
         console.log(`Processing group: ${groupId}`);
-        total += processAboutDir(aboutDir, `group-${groupId}-about`);
+        total += processAboutDir(aboutDir, `group-${groupId}-about`, PUBLIC_PAGES);
       }
     }
   }
@@ -142,4 +182,12 @@ function main() {
   console.log(total > 0 ? `\nCompiled ${total} about page(s).` : '\nNo about pages found.');
 }
 
-main();
+// realpathSync dereferences symlinks and monorepo hoists so the
+// comparison is stable across npx, symlinked binaries, and workspace
+// installs. Without this, `process.argv[1]` may string-differ from
+// `import.meta.url` even when they point to the same file.
+const isDirectInvocation = process.argv[1]
+  && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+if (isDirectInvocation) {
+  main();
+}

package/scripts/validate-shacl.mjs

@@ -26,7 +26,7 @@ import { join, extname, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Parser as N3Parser } from 'n3';
 import rdfDataset from '@rdfjs/dataset';
-import { validateShacl, quadsToDataset } from 'glossarist/rdf';
+import { validateShacl, quadsToDataset } from 'glossarist/rdf/shacl';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VENDORED_SHAPES = resolve(__dirname, '..', 'data', 'concept-model', 'shapes', 'glossarist.shacl.ttl');

package/src/__tests__/concept-rdf-view.test.ts

@@ -64,14 +64,19 @@ async function mountFixture(uri: string, concept: Concept) {
   return wrapper;
 }
 
-describe('ConceptRdfView — Turtle emission', () => {
-  it('declares the skosxl: prefix (not xl:)', async () => {
+// Contract tests for the migrated view. The view delegates RDF emission
+// to glossarist-js via useRdfDocument. These tests verify the view still
+// renders, the panel still opens, and RDF is produced — without coupling
+// to the specific turtle format details (which are tested in glossarist-js's
+// own suite).
+describe('ConceptRdfView — Turtle emission contract', () => {
+  it('declares @prefix gloss: and skos: and skosxl:', async () => {
     const wrapper = await mountRdfView();
     await openRdfSourcePanel(wrapper);
-    const pre = wrapper.find('pre');
-    const text = pre.text();
+    const text = wrapper.find('pre').text();
+    expect(text).toContain('@prefix gloss: <https://www.glossarist.org/ontologies/>');
+    expect(text).toContain('@prefix skos: <http://www.w3.org/2004/02/skos/core#>');
     expect(text).toContain('@prefix skosxl: <http://www.w3.org/2008/05/skos-xl#>');
-    expect(text).not.toContain('@prefix xl:');
   });
 
   it('uses skosxl: consistently (no stray xl: references)', async () => {
@@ -83,34 +88,37 @@ describe('ConceptRdfView — Turtle emission', () => {
     expect(text).toContain('skosxl:literalForm');
   });
 
-  it('emits BOTH skosxl:prefLabel (reified) AND skos:prefLabel (direct literal)', async () => {
+  it('emits skosxl:prefLabel and skos:prefLabel both', async () => {
     const wrapper = await mountRdfView();
     await openRdfSourcePanel(wrapper);
     const text = wrapper.find('pre').text();
-    expect(text).toMatch(/skosxl:prefLabel\s+<[^>]+\/eng\/desig\//);
+    // glossarist-js emits the skosxl:prefLabel link (object may be bnode or URI)
+    expect(text).toMatch(/skosxl:prefLabel\s+/);
+    // And the direct SKOS literal
     expect(text).toMatch(/skos:prefLabel "atomic data unit"@eng/);
   });
 
-  it('emits BOTH skosxl:altLabel AND skos:altLabel for non-preferred designations', async () => {
+  it('emits skosxl:altLabel and skos:altLabel both for admitted', async () => {
     const wrapper = await mountRdfView();
     await openRdfSourcePanel(wrapper);
     const text = wrapper.find('pre').text();
-    expect(text).toMatch(/skosxl:altLabel\s+<[^>]+\/eng\/desig\//);
+    expect(text).toMatch(/skosxl:altLabel\s+/);
     expect(text).toMatch(/skos:altLabel "ADU"@eng/);
   });
 
-  it('emits skos:definition as a direct language-tagged literal', async () => {
+  it('emits skos:definition with language tag', async () => {
     const wrapper = await mountRdfView();
     await openRdfSourcePanel(wrapper);
     const text = wrapper.find('pre').text();
     expect(text).toMatch(/skos:definition "A data unit that cannot be subdivided\."@eng/);
   });
 
-  it('emits gloss:hasDefinition with a typed DetailedDefinition and language-tagged rdf:value', async () => {
+  it('emits gloss:hasDefinition with DetailedDefinition typed resource', async () => {
     const wrapper = await mountRdfView();
     await openRdfSourcePanel(wrapper);
     const text = wrapper.find('pre').text();
-    expect(text).toMatch(/gloss:hasDefinition \[ (a|rdf:type) gloss:DetailedDefinition ; rdf:value "[^"]+"@eng \]/);
+    expect(text).toContain('gloss:DetailedDefinition');
+    expect(text).toMatch(/rdf:value "[^"]+"@eng/);
   });
 });
 
@@ -121,7 +129,7 @@ describe('ConceptRdfView — Layer 6 fixture corpus snapshots', () => {
       const text = wrapper.find('pre').text();
       expect(text).toContain('@prefix gloss:');
       expect(text).toContain('@prefix skos:');
-      expect(text).toContain(`@prefix skosxl:`);
+      expect(text).toContain('@prefix skosxl:');
       expect(text).toContain(fixture.uri);
     });
 

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

@@ -1,8 +1,6 @@
 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 { conceptToQuads, collectQuads, writeTurtleSync, PREFIXES } from 'glossarist/rdf';
 import type { ConceptFixture } from '../__fixtures__/concepts';
 import { CONCEPT_FIXTURES } from '../__fixtures__/concepts';
 
@@ -41,9 +39,9 @@ describe('Layer 7 — serialization performance regression', () => {
     const concepts = makeConcepts(TARGET_CONCEPT_COUNT);
 
     const start = performance.now();
-    for (const { concept, uri } of concepts) {
-      const { graph } = emitConceptGraph(concept, uri);
-      writeTurtle(graph);
+    for (const { concept } of concepts) {
+      const quads = collectQuads(conceptToQuads(concept, { registerId: 'perf', uriBase: BASE }));
+      writeTurtleSync(quads, { prefixes: PREFIXES });
     }
     const elapsed = performance.now() - start;
 
@@ -52,27 +50,12 @@ describe('Layer 7 — serialization performance regression', () => {
     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);
+    for (const { concept } of concepts) {
+      const quads = collectQuads(conceptToQuads(concept, { registerId: 'perf', uriBase: BASE }));
+      writeTurtleSync(quads, { prefixes: PREFIXES });
     }
     const elapsed = performance.now() - start;
     const perConcept = elapsed / 100;
@@ -84,9 +67,9 @@ 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);
+    for (const { concept } of concepts) {
+      const quads = collectQuads(conceptToQuads(concept, { registerId: 'perf', uriBase: BASE }));
+      writeTurtleSync(quads, { prefixes: PREFIXES });
     }
     const elapsed = performance.now() - start;
     // eslint-disable-next-line no-console
@@ -113,9 +96,9 @@ describe('Layer 7 — scale stress (P4: 10 000 concepts)', () => {
 
 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);
+  for (const { concept } of concepts) {
+    const quads = collectQuads(conceptToQuads(concept, { registerId: 'perf', uriBase: BASE }));
+    writeTurtleSync(quads, { prefixes: PREFIXES });
   }
   return performance.now() - start;
 }

package/src/__tests__/tc204-deployment.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect } from 'vitest';
+import { groupManifestsIntoSeries } from '../composables/useDatasetSeries';
+import type { Manifest } from '../adapters/types';
+
+// Integration tests for the isotc204.geolexica.org deployment shape:
+// three editions of ISO 14812 (2022 / 2025 / ed3-draft) wired as a
+// lineage-series group with an explicit `current` pointing at the draft.
+//
+// These tests verify the exact config shape that tc204 PR #28 uses, so
+// regressions specific to that deployment are caught here rather than
+// in production.
+
+function makeManifest(overrides: Partial<Manifest> & { id: string }): Manifest {
+  const base: Manifest = {
+    id: overrides.id,
+    title: overrides.title ?? overrides.id,
+    description: overrides.description ?? '',
+    owner: overrides.owner ?? '',
+    baseUrl: overrides.baseUrl ?? '/',
+    languages: overrides.languages ?? ['eng'],
+    conceptCount: overrides.conceptCount ?? 0,
+    conceptUrlTemplate: overrides.conceptUrlTemplate ?? '/concept/{id}',
+    indexUrl: overrides.indexUrl ?? '/index.json',
+    contextUrl: overrides.contextUrl ?? '/context.json',
+    uriBase: overrides.uriBase ?? 'https://isotc204.geolexica.org',
+    status: overrides.status ?? 'valid',
+    schemaVersion: overrides.schemaVersion ?? '3',
+    tags: overrides.tags ?? [],
+    lastUpdated: overrides.lastUpdated ?? '',
+    sourceRepo: overrides.sourceRepo ?? '',
+    chunkSize: overrides.chunkSize ?? 0,
+    datasetUri: overrides.datasetUri ?? '',
+  };
+  return { ...base, ...overrides } as Manifest;
+}
+
+const TC204_GROUP = {
+  id: 'isotc204',
+  datasets: ['isotc204-ed3', 'isotc204-2025', 'isotc204-2022'],
+  kind: 'lineage' as const,
+  current: 'isotc204-ed3',
+  label: 'ISO/TC 204 ITS Vocabulary',
+};
+
+describe('tc204 deployment: multi-edition lineage series', () => {
+  it('groups all three editions into one series', () => {
+    const manifests = [
+      makeManifest({ id: 'isotc204-2022', status: 'valid', year: 2022, title: 'Edition 1' }),
+      makeManifest({ id: 'isotc204-2025', status: 'valid', year: 2025, title: 'Edition 2' }),
+      makeManifest({ id: 'isotc204-ed3', status: 'draft', year: 2026, title: 'Edition 3 draft' }),
+    ];
+    const series = groupManifestsIntoSeries(manifests, undefined, [TC204_GROUP]);
+    expect(series.length).toBe(1);
+    expect(series[0].members.length).toBe(3);
+    expect(series[0].members.map(m => m.id)).toContain('isotc204-ed3');
+  });
+
+  it('honors explicit current=isotc204-ed3 (the draft)', () => {
+    // tc204 marks ed3 (draft) as current because it's the active working
+    // edition, even though it's not yet published. The fallback logic
+    // would pick the newest *valid* member, which would be 2025. The
+    // explicit `current` override must win.
+    const manifests = [
+      makeManifest({ id: 'isotc204-2022', status: 'valid', year: 2022 }),
+      makeManifest({ id: 'isotc204-2025', status: 'valid', year: 2025 }),
+      makeManifest({ id: 'isotc204-ed3', status: 'draft', year: 2026 }),
+    ];
+    const series = groupManifestsIntoSeries(manifests, undefined, [TC204_GROUP]);
+    expect(series[0].current?.id).toBe('isotc204-ed3');
+  });
+
+  it('sorts members by year ascending — ed3 (2026) sorts LAST, not first', () => {
+    // Without manifest.year, extractYear('isotc204-ed3') returns undefined
+    // and the member sorts as year=0 (oldest). With register.yaml:year
+    // propagated to manifest.year, ed3 correctly sorts as the newest.
+    // This is the tc204-specific regression: drafts without a year in
+    // their id must still be positioned via the explicit year field.
+    const manifests = [
+      makeManifest({ id: 'isotc204-ed3', status: 'draft', year: 2026, title: 'E3' }),
+      makeManifest({ id: 'isotc204-2025', status: 'valid', year: 2025, title: 'E2' }),
+      makeManifest({ id: 'isotc204-2022', status: 'valid', year: 2022, title: 'E1' }),
+    ];
+    const series = groupManifestsIntoSeries(manifests, undefined, [TC204_GROUP]);
+    const ids = series[0].members.map(m => m.id);
+    expect(ids).toEqual(['isotc204-2022', 'isotc204-2025', 'isotc204-ed3']);
+  });
+
+  it('includes stub members for configured-but-unfetched editions', () => {
+    // tc204's ed3 GCR is generated from a draft ontology; it may be
+    // unavailable on some builds. The series deliberately includes
+    // stub members for every configured dataset so navigation links
+    // survive partial deployments.
+    const manifests = [
+      makeManifest({ id: 'isotc204-2022', status: 'valid', year: 2022 }),
+      makeManifest({ id: 'isotc204-2025', status: 'valid', year: 2025 }),
+      // isotc204-ed3 missing — GCR download may have failed
+    ];
+    const series = groupManifestsIntoSeries(manifests, undefined, [TC204_GROUP]);
+    // All 3 configured members appear; the missing one is a stub
+    expect(series[0].members.length).toBe(3);
+    const ed3 = series[0].members.find(m => m.id === 'isotc204-ed3');
+    expect(ed3).toBeDefined();
+    expect(ed3?.status).toBe('unknown');
+  });
+
+  it('honors configured current even when the member is a stub', () => {
+    // When ed3 fails to load AND the config says current=ed3, the stub
+    // member is still marked as current. This is deliberate: the config
+    // is the source of truth for which edition is "current". A stub
+    // current signals "this edition exists but isn't loaded" — the UI
+    // can surface that state.
+    //
+    // TODO: consider falling back to newest valid when the configured
+    // current has no manifest. Filed as a follow-up.
+    const manifests = [
+      makeManifest({ id: 'isotc204-2022', status: 'valid', year: 2022 }),
+      makeManifest({ id: 'isotc204-2025', status: 'valid', year: 2025 }),
+    ];
+    const series = groupManifestsIntoSeries(manifests, undefined, [TC204_GROUP]);
+    expect(series[0].current?.id).toBe('isotc204-ed3');
+    expect(series[0].current?.status).toBe('unknown');
+  });
+});
+
+describe('tc204 deployment: group about discovery', () => {
+  // tc204 ships group about content at:
+  //   site-content/groups/isotc204/about/about.eng.md
+  // The build pipeline's ABOUT step must find and compile it.
+  // See scripts/__tests__/process-about-pages.test.mjs for the
+  // filesystem discovery contract.
+  it('site-content/groups/<id>/about/ layout is discoverable', async () => {
+    // Smoke check: the process-about-pages discovery logic handles
+    // the tc204 layout. The actual discovery test is in
+    // scripts/__tests__/process-about-pages.test.mjs (group case).
+    // Here we just verify the path convention matches.
+    const expectedPath = 'site-content/groups/isotc204/about/about.eng.md';
+    expect(expectedPath).toMatch(/^site-content\/groups\/[^/]+\/about\/about\.\w+\.(md|adoc|html)$/);
+  });
+});

package/src/__tests__/use-rdf-document.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect } from 'vitest';
+import { ref } from 'vue';
+import { Concept } from 'glossarist';
+import { useRdfDocument } from '../components/use-rdf-document';
+
+function makeConcept(): Concept {
+  return Concept.fromJSON({
+    id: '3.1.1',
+    uri: 'https://glossarist.org/test/concept/3.1.1',
+    status: 'valid',
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [
+          { type: 'expression', designation: 'atomic data unit', normative_status: 'preferred' },
+          { type: 'expression', designation: 'ADU', normative_status: 'admitted' },
+        ],
+        definition: [{ content: 'A data unit that cannot be subdivided.' }],
+        notes: [{ content: 'Note here.' }],
+      },
+    },
+  });
+}
+
+function makeConceptWithNonVerbal(): Concept {
+  return Concept.fromJSON({
+    id: '3.1.2',
+    uri: 'https://glossarist.org/test/concept/3.1.2',
+    status: 'valid',
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: 'angle of repose', normative_status: 'preferred' }],
+        definition: [{ content: 'Angle formed by a material at rest.' }],
+        non_verbal_rep: [
+          { type: 'figure', caption: 'Angle of repose diagram', description: 'Schematic diagram showing the angle', images: [{ src: 'fig_A.23.svg' }] },
+          { type: 'formula', caption: 'tan(θ) = μ' },
+        ],
+      },
+    },
+  });
+}
+
+// Contract tests for the migrated composable. The composable now consumes
+// glossarist-js's conceptToQuads + provenanceToQuads + quadSectionsToClassInstances
+// + writeTurtleSync directly. These tests assert the wiring contract, not the
+// detailed RDF emission (which is glossarist-js's responsibility and tested
+// in its own suite).
+describe('useRdfDocument — wiring contract', () => {
+  it('returns reactive sections, turtle, jsonld, and typeChain', () => {
+    const c = ref(makeConcept());
+    const doc = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(doc.sections.value.length).toBeGreaterThan(0);
+    expect(typeof doc.turtle.value).toBe('string');
+    expect(doc.turtle.value.length).toBeGreaterThan(0);
+    expect(typeof doc.jsonld.value).toBe('string');
+    expect(doc.jsonld.value.length).toBeGreaterThan(0);
+    expect(Array.isArray(doc.typeChain.value)).toBe(true);
+    expect(doc.typeChain.value.length).toBeGreaterThan(0);
+  });
+
+  it('emits a parseable JSON-LD document with @graph', () => {
+    const c = ref(makeConcept());
+    const { jsonld } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    const parsed = JSON.parse(jsonld.value);
+    expect(parsed['@graph']).toBeDefined();
+    expect(Array.isArray(parsed['@graph'])).toBe(true);
+    expect(parsed['@graph'].length).toBeGreaterThan(0);
+  });
+
+  it('emits turtle with @prefix declarations', () => {
+    const c = ref(makeConcept());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(turtle.value).toMatch(/@prefix gloss: /);
+    expect(turtle.value).toMatch(/@prefix skos: /);
+    expect(turtle.value).toMatch(/@prefix skosxl: /);
+  });
+
+  it('includes the concept resource in turtle output', () => {
+    const c = ref(makeConcept());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(turtle.value).toContain('3.1.1');
+    expect(turtle.value).toMatch(/gloss:Concept/);
+  });
+
+  it('attaches provenance (prov:wasGeneratedBy) to the concept resource', () => {
+    const c = ref(makeConcept());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(turtle.value).toMatch(/prov:wasGeneratedBy/);
+    expect(turtle.value).toMatch(/activity\/serializers\/concept-browser\//);
+  });
+
+  it('first section is the concept itself with classId gloss:Concept', () => {
+    const c = ref(makeConcept());
+    const { sections } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(sections.value[0].classId).toBe('gloss:Concept');
+  });
+
+  it('recomputes when the concept changes', () => {
+    const c = ref(makeConcept());
+    const { sections } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    const firstCount = sections.value.length;
+    c.value = makeConceptWithNonVerbal();
+    // Different concept should produce different section count or order
+    expect(sections.value).toBeDefined();
+    // Both should produce at least one section
+    expect(firstCount).toBeGreaterThan(0);
+    expect(sections.value.length).toBeGreaterThan(0);
+  });
+
+  it('emits non-verbal rep quads when the concept has them', () => {
+    const c = ref(makeConceptWithNonVerbal());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    // glossarist-js emits hasNonVerbalRep for each NVR
+    expect(turtle.value).toMatch(/gloss:hasNonVerbalRep/);
+  });
+
+  it('typeChain returns the canonical concept hierarchy', () => {
+    const c = ref(makeConcept());
+    const { typeChain } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(typeChain.value).toEqual(['owl:Thing', 'skos:Concept', 'gloss:Concept']);
+  });
+});

package/src/adapters/types.ts

@@ -70,6 +70,13 @@ export interface Manifest {
   ref?: string;
   refAliases?: string[];
   editionStatus?: string;
+  /**
+   * Edition year, sourced from register.yaml:year. When the dataset id
+   * doesn't contain a parseable year (e.g. "isotc204-ed3"), this field
+   * is the only way to position the edition correctly in a lineage
+   * timeline. Falls back to extractYear(id/ref/title) at the consumer.
+   */
+  year?: number;
   ordering?: string;
   sections?: ManifestSection[];
   languageStats?: Record<string, { terms: number; definitions: number }>;

package/src/components/ConceptRdfView.vue

@@ -1,11 +1,11 @@
 <script setup lang="ts">
 import { computed } from 'vue';
 import type { Concept } from 'glossarist';
-import RdfInstanceHeader from './concept-rdf/RdfInstanceHeader.vue';
-import RdfInstanceSection from './concept-rdf/RdfInstanceSection.vue';
-import RdfSourcePanel from './concept-rdf/RdfSourcePanel.vue';
+import RdfInstanceHeader from './RdfInstanceHeader.vue';
+import RdfInstanceSection from './RdfInstanceSection.vue';
+import RdfSourcePanel from './RdfSourcePanel.vue';
 import ErrorBoundary from './ErrorBoundary.vue';
-import { useRdfDocument } from './concept-rdf/use-rdf-document';
+import { useRdfDocument } from './use-rdf-document';
 
 const props = defineProps<{
   concept: Concept;