@glossarist/concept-browser 0.7.65 → 0.7.67

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__/scripts/agents-turtle.test.ts

@@ -1,6 +1,8 @@
 import { describe, it, expect } from 'vitest';
 import { Parser, Store } from 'n3';
-import { buildAgentsTurtle } from '../../../scripts/lib/agents-turtle.mjs';
+import { buildAgentsTurtle as _buildAgentsTurtle } from '../../../scripts/lib/agents-turtle.mjs';
+
+const buildAgentsTurtle = _buildAgentsTurtle as unknown as (...args: any[]) => Promise<string>;
 
 function parse(turtle: string): Store {
   const parser = new Parser({ format: 'Turtle' });
@@ -16,13 +18,13 @@ const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
 
 describe('buildAgentsTurtle (mjs)', () => {
   it('parses without errors', async () => {
-    const ttl = await buildAgentsTurtle([{ name: 'Ada Lovelace' }], 'https://glossarist.org/agent');
+    const ttl = await buildAgentsTurtle([{ name: 'Ada Lovelace' }], 'https://glossarist.org/agent', 'https://glossarist.org/org');
     const store = parse(ttl);
     expect(store.size).toBeGreaterThan(0);
   });
 
   it('types each person as foaf:Person, prov:Person, prov:Agent', async () => {
-    const ttl = await buildAgentsTurtle([{ name: 'Ada Lovelace' }], 'https://glossarist.org/agent');
+    const ttl = await buildAgentsTurtle([{ name: 'Ada Lovelace' }], 'https://glossarist.org/agent', 'https://glossarist.org/org');
     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`);
@@ -33,7 +35,7 @@ describe('buildAgentsTurtle (mjs)', () => {
   it('records name, mailto mbox, role, and seeAlso', async () => {
     const ttl = await buildAgentsTurtle([
       { name: 'Ada Lovelace', email: 'ada@example.org', role: 'Editor', url: 'https://example.org/ada' },
-    ], 'https://glossarist.org/agent');
+    ], 'https://glossarist.org/agent', 'https://glossarist.org/org');
     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');
@@ -46,7 +48,7 @@ describe('buildAgentsTurtle (mjs)', () => {
     const ttl = await buildAgentsTurtle([
       { name: 'Alice', organization: 'ISO' },
       { name: 'Bob',   organization: 'ISO' },
-    ], 'https://glossarist.org/agent');
+    ], 'https://glossarist.org/agent', 'https://glossarist.org/org');
     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`);
@@ -54,8 +56,18 @@ describe('buildAgentsTurtle (mjs)', () => {
   });
 
   it('emits only prefix declarations for an empty input', async () => {
-    const ttl = await buildAgentsTurtle([], 'https://glossarist.org/agent');
+    const ttl = await buildAgentsTurtle([], 'https://glossarist.org/agent', 'https://glossarist.org/org');
     expect(ttl).toContain('@prefix foaf:');
     expect(ttl).not.toContain('<https://glossarist.org/agent/');
   });
+
+  it('throws when agentBase is missing (no hardcoded default)', async () => {
+    await expect(buildAgentsTurtle([{ name: 'X' }])).rejects.toThrow('agentBase');
+  });
+
+  it('throws when orgBase is missing (no hardcoded default)', async () => {
+    await expect(
+      buildAgentsTurtle([{ name: 'X' }], 'https://example.org/agent'),
+    ).rejects.toThrow('orgBase');
+  });
 });

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

@@ -14,6 +14,7 @@ function makeInput(overrides: any = {}): any {
     datasetRegisters: ['iso-geodetic'],
     conceptCount: 1234,
     associatedAgentIri: 'https://glossarist.org/agent/ci-bot',
+    baseUri: 'https://glossarist.org',
     ...overrides,
   };
 }
@@ -72,4 +73,9 @@ describe('buildActivityTurtle (mjs)', () => {
     const agents = store.getObjects(ACTIVITY_IRI(input.runId), expand('prov:wasAssociatedWith'), null).map(q => q.value);
     expect(agents).toContain(input.associatedAgentIri);
   });
+
+  it('throws when baseUri is missing (no hardcoded default)', async () => {
+    const { baseUri, ...inputWithoutBaseUri } = makeInput();
+    await expect(buildActivityTurtle(inputWithoutBaseUri)).rejects.toThrow('baseUri');
+  });
 });

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

@@ -46,6 +46,7 @@ describe('WS F Layer 8 — build pipeline integration', () => {
     const out = runInline(`
       import { buildActivityTurtle } from './scripts/lib/build-activity-turtle.mjs';
       console.log(await buildActivityTurtle({
+        baseUri: 'https://glossarist.org',
         runId: 'test', startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:05:00Z',
         toolId: 'cb', toolVersion: '0.7.52', datasetRegisters: [], conceptCount: 0,
       }));
@@ -61,7 +62,7 @@ describe('WS F Layer 8 — build pipeline integration', () => {
   it('agents-turtle.mjs produces parseable foaf:Person', () => {
     const out = runInline(`
       import { buildAgentsTurtle } from './scripts/lib/agents-turtle.mjs';
-      console.log(await buildAgentsTurtle([{ name: 'Ada Lovelace', role: 'Editor', organization: 'Royal Society' }], 'https://glossarist.org/agent'));
+      console.log(await buildAgentsTurtle([{ name: 'Ada Lovelace', role: 'Editor', organization: 'Royal Society' }], 'https://glossarist.org/agent', 'https://glossarist.org/org'));
     `);
     const store = parseTurtle(out);
     const persons = [...store].filter(q =>
@@ -121,8 +122,8 @@ describe('WS F Layer 8 — build pipeline integration', () => {
       const parts = [
         await buildVocabularyTurtle(),
         await buildDatasetTurtle({ datasetIri: 'https://glossarist.org/test/', registerId: 'test', title: 't', modified: '2026-01-01', languages: ['eng'], distributions: [], topConceptUris: [], sections: [] }),
-        await buildActivityTurtle({ runId: 'r', startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:05:00Z', toolId: 'cb', toolVersion: '0', datasetRegisters: [], conceptCount: 0 }),
-        await buildAgentsTurtle([{ name: 'Ada' }], 'https://glossarist.org/agent'),
+        await buildActivityTurtle({ baseUri: 'https://glossarist.org', runId: 'r', startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:05:00Z', toolId: 'cb', toolVersion: '0', datasetRegisters: [], conceptCount: 0 }),
+        await buildAgentsTurtle([{ name: 'Ada' }], 'https://glossarist.org/agent', 'https://glossarist.org/org'),
         await buildBibliographyTurtle('test', { x: { reference: 'X' } }, 'https://glossarist.org'),
         await buildVersionHistoryTurtle({ registerId: 't', datasetIri: 'https://glossarist.org/t/', versions: [{ version: '1', generatedAt: '2026-01-01' }] }),
       ];

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/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;