@glossarist/concept-browser 0.7.66 → 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__/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;

package/src/components/use-rdf-document.ts

@@ -0,0 +1,137 @@
+import type { ComputedRef } from 'vue';
+import { computed } from 'vue';
+import type { Concept } from 'glossarist';
+import {
+  conceptToQuads,
+  provenanceToQuads,
+  quadSectionsToClassInstances,
+  writeTurtleSync,
+  collectQuads,
+  PREFIXES,
+  type ClassInstance,
+  type PropValue,
+  type Quad,
+} from 'glossarist/rdf';
+
+export type { ClassInstance, PropValue };
+
+export interface RdfDocument {
+  sections: ComputedRef<ClassInstance[]>;
+  turtle: ComputedRef<string>;
+  jsonld: ComputedRef<string>;
+  typeChain: ComputedRef<string[]>;
+}
+
+export interface UseRdfDocumentOptions {
+  readonly registerId?: string;
+  readonly uriBase?: string;
+  readonly lazy?: boolean;
+}
+
+const SERIALIZER_VERSION =
+  typeof __CONCEPT_BROWSER_VERSION__ !== 'undefined'
+    ? __CONCEPT_BROWSER_VERSION__
+    : 'dev';
+
+function formatJsonLd(quads: readonly Quad[]): string {
+  // Minimal sync JSON-LD serializer: @context + @graph array of nodes.
+  // Predicates and types are emitted as compact IRIs; values are emitted
+  // as their term-type-appropriate JSON form.
+  const context: Record<string, string> = {};
+  for (const prefix of ['gloss', 'skos', 'skosxl', 'dcterms', 'prov', 'rdf', 'rdfs', 'xsd', 'owl']) {
+    // Skip — handled by RDF_PREFIXES for the Vue UI; JSON-LD context is
+    // minimal here because glossarist/rdf's writeJsonld is async and
+    // the composable must stay sync.
+  }
+
+  // Group quads by subject
+  const bySubject = new Map<string, { subject: string; quads: Quad[] }>();
+  const order: string[] = [];
+  for (const q of quads) {
+    const s = q.subject.value;
+    if (!bySubject.has(s)) {
+      bySubject.set(s, { subject: s, quads: [] });
+      order.push(s);
+    }
+    bySubject.get(s)!.quads.push(q);
+  }
+
+  const nodes = order.map(s => {
+    const entry = bySubject.get(s)!;
+    const node: Record<string, unknown> = { '@id': entry.subject };
+    const types: string[] = [];
+    const props: Record<string, unknown[]> = {};
+
+    for (const q of entry.quads) {
+      if (q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type') {
+        types.push(q.object.value);
+        continue;
+      }
+      const pred = q.predicate.value;
+      const val = termToJsonLd(q.object);
+      if (!props[pred]) props[pred] = [];
+      props[pred].push(val);
+    }
+
+    if (types.length === 1) node['@type'] = types[0];
+    else if (types.length > 1) node['@type'] = types;
+
+    for (const [pred, vals] of Object.entries(props)) {
+      node[pred] = vals.length === 1 ? vals[0] : vals;
+    }
+    return node;
+  });
+
+  return JSON.stringify({ '@context': context, '@graph': nodes }, null, 2);
+}
+
+function termToJsonLd(term: Quad['object']): unknown {
+  switch (term.termType) {
+    case 'NamedNode':
+      return { '@id': term.value };
+    case 'Literal':
+      if (term.language) return { '@value': term.value, '@language': term.language };
+      if (term.datatype && term.datatype.value !== 'http://www.w3.org/2001/XMLSchema#string') {
+        return { '@value': term.value, '@type': term.datatype.value };
+      }
+      return term.value;
+    case 'BlankNode':
+      return { '@id': `_:${term.value}` };
+    default:
+      return term.value;
+  }
+}
+
+export function useRdfDocument(
+  getConcept: () => Concept,
+  getConceptUri: () => string,
+  options: UseRdfDocumentOptions = {},
+): RdfDocument {
+  const emission = computed(() => {
+    const concept = getConcept();
+    const uri = getConceptUri();
+    const conceptQuads = collectQuads(
+      conceptToQuads(concept, {
+        registerId: options.registerId ?? '',
+        uriBase: options.uriBase ?? '',
+      }),
+    );
+    const provenanceQuads = collectQuads(
+      provenanceToQuads({
+        subjectUri: uri,
+        serializer: 'concept-browser',
+        serializerVersion: SERIALIZER_VERSION,
+        generatedAt: new Date().toISOString(),
+      }),
+    );
+    return [...conceptQuads, ...provenanceQuads];
+  });
+
+  const sections = computed(() => quadSectionsToClassInstances(emission.value));
+  const turtle = computed(() => writeTurtleSync(emission.value, { prefixes: PREFIXES }));
+  const jsonld = computed(() => formatJsonLd(emission.value));
+
+  const typeChain = computed(() => ['owl:Thing', 'skos:Concept', 'gloss:Concept']);
+
+  return { sections, turtle, jsonld, typeChain };
+}