@glossarist/concept-browser 0.7.60 → 0.7.62

package/README.md

@@ -432,7 +432,7 @@ Sites currently powered by `@glossarist/concept-browser`. When cutting a release
 | [`geolexica/osgeo.geolexica.org`](https://github.com/geolexica/osgeo.geolexica.org) | https://osgeo.geolexica.org |
 | [`oimlsmart/vocab`](https://github.com/oimlsmart/vocab) | https://www.oimlsmart.org/vocab/ (VIML)¹ |
 | [`metanorma/oiml-terms`](https://github.com/metanorma/oiml-terms) | https://metanorma.github.io/oiml-terms/ |
-| [`metanorma/iala-vocab`](https://github.com/metanorma/iala-vocab) | https://metanorma.github.io/iala-vocab/ |
+| [`glossarist/iala-vocab`](https://github.com/glossarist/iala-vocab) | https://glossarist.github.io/iala-vocab/ |
 | [`metanorma/iso-10303-2-vocab`](https://github.com/metanorma/iso-10303-2-vocab) | https://metanorma.github.io/iso-10303-2-vocab/ |
 
 To add a new deployment here, open a PR against this README.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.60",
+  "version": "0.7.62",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -31,7 +31,7 @@
     "autoprefixer": "^10.4.21",
     "d3": "^7.9.0",
     "favicons": "^7.2.0",
-    "glossarist": "^0.4.9",
+    "glossarist": "^0.4.10",
     "js-yaml": "^4.1.0",
     "jszip": "^3.10.1",
     "pinia": "^2.3.1",

package/scripts/generate-data.mjs

@@ -91,7 +91,7 @@ function writeJson(filePath, data) {
   fs.writeFileSync(filePath, JSON.stringify(data));
 }
 
-function writeDatasetRdf(register, manifest, concepts, refMaps, opts) {
+async function writeDatasetRdf(register, manifest, concepts, refMaps, opts) {
   const uriBase = refMaps?.uriBase ?? 'https://glossarist.org';
   const datasetIri = `${uriBase}/${register}/`;
   const topConceptUris = concepts
@@ -122,7 +122,7 @@ function writeDatasetRdf(register, manifest, concepts, refMaps, opts) {
     },
   ];
 
-  const ttl = buildDatasetTurtle({
+  const ttl = await buildDatasetTurtle({
     datasetIri,
     registerId: register,
     title: manifest.title ?? register,
@@ -139,7 +139,7 @@ function writeDatasetRdf(register, manifest, concepts, refMaps, opts) {
   fs.writeFileSync(path.join(DATA, register, `${register}.ttl`), ttl);
 }
 
-function writeBuildActivity(conceptCount, datasetRegisters) {
+async function writeBuildActivity(conceptCount, datasetRegisters) {
   const runId = process.env.GITHUB_RUN_ID
     ? `${process.env.GITHUB_RUN_ID}-${process.env.GITHUB_RUN_ATTEMPT ?? '1'}`
     : `local-${new Date().toISOString().replace(/[:.]/g, '-')}`;
@@ -150,7 +150,7 @@ function writeBuildActivity(conceptCount, datasetRegisters) {
   const pkgVersion = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')).version;
   const agentIri = process.env.CI_BOT_AGENT_IRI ?? null;
 
-  const ttl = buildActivityTurtle({
+  const ttl = await buildActivityTurtle({
     runId,
     startedAt,
     endedAt,
@@ -1092,7 +1092,7 @@ async function processDataset(dir, register, opts) {
   writeJson(path.join(DATA, register, 'manifest.json'), manifest);
 
   // Dataset-level RDF (WS J2/J5): dcat:Dataset + skos:ConceptScheme + skos:Collection per section.
-  writeDatasetRdf(register, manifest, concepts, refMaps, opts);
+  await writeDatasetRdf(register, manifest, concepts, refMaps, opts);
 
   // Copy bibliography.yaml → bibliography.json
   const bibPath = path.join(sourceRoot, 'bibliography.yaml');
@@ -1610,14 +1610,14 @@ for (const [id, count] of Object.entries(counts)) {
   console.log(`  ${id}: ${count} concepts`);
 }
 
-writeBuildActivity(total, registry.map(r => r.id));
+await writeBuildActivity(total, registry.map(r => r.id));
 
 fs.writeFileSync(path.join(DATA, '_vocab.ttl'), await buildVocabularyTurtle());
 console.log('Emitted vocabulary graph: data/_vocab.ttl');
 
 const contributors = config.contributors ?? [];
 if (contributors.length > 0) {
-  fs.writeFileSync(path.join(DATA, 'agents.ttl'), buildAgentsTurtle(contributors));
+  fs.writeFileSync(path.join(DATA, 'agents.ttl'), await buildAgentsTurtle(contributors));
   console.log(`Emitted agents graph: data/agents.ttl (${contributors.length} contributors)`);
 }
 
@@ -1626,7 +1626,7 @@ for (const ds of registry) {
   const bibPath = path.join(DATA, ds.id, 'bibliography.json');
   if (fs.existsSync(bibPath)) {
     const bibJson = JSON.parse(fs.readFileSync(bibPath, 'utf8'));
-    const bibTtl = buildBibliographyTurtle(ds.id, bibJson);
+    const bibTtl = await buildBibliographyTurtle(ds.id, bibJson);
     fs.writeFileSync(path.join(DATA, ds.id, 'bib.ttl'), bibTtl);
   }
 }
@@ -1644,14 +1644,14 @@ const datasetVersions = registry.map(ds => ({
 }));
 
 if (datasetVersions.length > 0) {
-  const versionTtl = datasetVersions.map(v =>
+  const versionTtl = (await Promise.all(datasetVersions.map(v =>
     buildVersionHistoryTurtle({
       registerId: v.registerId,
       datasetIri: v.datasetIri,
       versions: v.versions,
       associatedAgentIri: process.env.CI_BOT_AGENT_IRI ?? null,
     }),
-  ).join('\n');
+  ))).join('\n');
   fs.writeFileSync(path.join(DATA, 'versions.ttl'), versionTtl);
   console.log(`Emitted versions graph: data/versions.ttl (${datasetVersions.length} datasets)`);
 }

package/scripts/lib/agents-turtle.mjs

@@ -1,64 +1,26 @@
-function slugify(input) {
-  return String(input)
-    .toLowerCase()
-    .normalize('NFKD')
-    .replace(/[̀-ͯ]/g, '')
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-}
+// Agents turtle builder — emits foaf:Person / prov:Organization from
+// contributor declarations.
+//
+// Delegates to glossarist-js's agents emitter + writeTurtle.
 
-function ttlLit(s) {
-  if (s == null) return '""';
-  const escaped = String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-  return `"${escaped}"`;
-}
+import {
+  agentsFromContributors,
+  agentsToQuads,
+  collectQuads,
+  writeTurtle,
+} from 'glossarist/rdf';
 
-function ttlPrefixed(qname) {
-  const colonIdx = qname.indexOf(':');
-  if (colonIdx < 0) return qname;
-  const local = qname.slice(colonIdx + 1);
-  const escaped = local.replace(/([/])/g, '\\$1');
-  return `${qname.slice(0, colonIdx + 1)}${escaped}`;
+function writerPrefixes() {
+  return {
+    foaf: 'http://xmlns.com/foaf/0.1/',
+    prov: 'http://www.w3.org/ns/prov#',
+    dcterms: 'http://purl.org/dc/terms/',
+    rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+  };
 }
 
-export function buildAgentsTurtle(contributors, agentBase = 'https://glossarist.org/agent') {
-  const lines = [];
-  lines.push('@prefix foaf: <http://xmlns.com/foaf/0.1/> .');
-  lines.push('@prefix prov: <http://www.w3.org/ns/prov#> .');
-  lines.push('@prefix dcterms: <http://purl.org/dc/terms/> .');
-  lines.push('@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .');
-  lines.push('');
-
-  const orgSlugs = new Set();
-  for (const c of contributors ?? []) {
-    const slug = slugify(c.name);
-    const iri = `${agentBase}/${slug}`;
-    const personLines = [
-      `<${iri}> a foaf:Person, prov:Person, prov:Agent ;`,
-      `  foaf:name ${ttlLit(c.name)} ;`,
-    ];
-    if (c.email) personLines.push(`  foaf:mbox <mailto:${c.email}> ;`);
-    if (c.url) personLines.push(`  rdfs:seeAlso <${c.url}> ;`);
-    if (c.role) personLines.push(`  dcterms:description ${ttlLit(c.role)} ;`);
-    personLines[personLines.length - 1] = personLines[personLines.length - 1].replace(/ ;$/, ' .');
-    lines.push(...personLines);
-
-    if (c.organization) {
-      const orgSlug = slugify(c.organization);
-      const orgIri = `https://glossarist.org/org/${orgSlug}`;
-      lines[lines.length - 1] = lines[lines.length - 1].replace(/\.$/, ` ;\n  prov:actedOnBehalfOf <${orgIri}> .`);
-
-      if (!orgSlugs.has(orgSlug)) {
-        orgSlugs.add(orgSlug);
-        const orgLines = [
-          ``,
-          `<${orgIri}> a foaf:Organization, prov:Organization, prov:Agent ;`,
-          `  foaf:name ${ttlLit(c.organization)} .`,
-        ];
-        lines.push(...orgLines);
-      }
-    }
-    lines.push('');
-  }
-  return lines.join('\n');
-}
+export async function buildAgentsTurtle(contributors, agentBase = 'https://glossarist.org/agent') {
+  const agents = agentsFromContributors(contributors ?? [], agentBase);
+  const quads = collectQuads(agentsToQuads(agents));
+  return writeTurtle(quads, { prefixes: writerPrefixes() });
+}

package/scripts/lib/bibliography-turtle.mjs

@@ -1,54 +1,29 @@
-import { ttlLit, ttlIri } from './turtle-escape.mjs';
+// Bibliography turtle builder — emits dcterms:BibliographicResource
+// per bibliography entry.
+//
+// Delegates to glossarist-js's bibliography emitter + writeTurtle.
 
-function entryFromV3(e, fallbackId) {
+import {
+  bibliographyToQuads,
+  normalizeBibliographyData,
+  collectQuads,
+  writeTurtle,
+} from 'glossarist/rdf';
+
+const DEFAULT_BASE_URI = 'https://glossarist.org';
+
+function writerPrefixes() {
   return {
-    id: e.id ?? fallbackId ?? '',
-    reference: e.reference ?? '',
-    title: e.title,
-    link: e.link,
-    type: e.type,
+    dcterms: 'http://purl.org/dc/terms/',
+    foaf: 'http://xmlns.com/foaf/0.1/',
+    gloss: 'https://www.glossarist.org/ontologies/',
   };
 }
 
-export function normalizeBibliographyData(raw) {
-  if (!raw || typeof raw !== 'object') return [];
-  if (Array.isArray(raw.bibliography)) {
-    return raw.bibliography.map(e => entryFromV3(e));
-  }
-  const entries = [];
-  for (const [id, value] of Object.entries(raw)) {
-    if (!value || typeof value !== 'object') continue;
-    entries.push(entryFromV3(value, id));
-  }
-  return entries;
-}
-
-export function buildBibliographyTurtle(register, bibliographyJson, baseUri = 'https://glossarist.org') {
-  const lines = [
-    '@prefix dcterms: <http://purl.org/dc/terms/> .',
-    '@prefix foaf: <http://xmlns.com/foaf/0.1/> .',
-    '@prefix gloss: <https://www.glossarist.org/ontologies/> .',
-    '',
-  ];
+export { normalizeBibliographyData };
 
-  const datasetIri = `${baseUri}/${register}/`;
+export async function buildBibliographyTurtle(register, bibliographyJson, baseUri = DEFAULT_BASE_URI) {
   const entries = normalizeBibliographyData(bibliographyJson);
-
-  for (const entry of entries) {
-    if (!entry.id || !entry.reference) continue;
-    /* Percent-encode the bib id when embedding it in an IRI — many
-       bibliography ids contain spaces or other reserved chars
-       (e.g. "ISO/IEC 17000:2020") which are forbidden in raw IRI form. */
-    const bibIri = `${datasetIri}bib/${encodeURIComponent(entry.id)}`;
-    lines.push(`${ttlIri(bibIri)} a dcterms:BibliographicResource ;`);
-    lines.push(`  dcterms:identifier ${ttlLit(entry.id)} ;`);
-    lines.push(`  dcterms:bibliographicCitation ${ttlLit(entry.reference)} ;`);
-    if (entry.title) lines.push(`  dcterms:title ${ttlLit(entry.title)} ;`);
-    if (entry.link) lines.push(`  foaf:page ${ttlIri(entry.link)} ;`);
-    if (entry.type) lines.push(`  dcterms:type ${ttlIri(`${baseUri}/${register}/bibtype/${entry.type}`)} ;`);
-    lines.push(`  dcterms:isPartOf ${ttlIri(datasetIri)} .`);
-    lines.push('');
-  }
-
-  return lines.join('\n');
-}
+  const quads = collectQuads(bibliographyToQuads({ registerId: register, entries, baseUri }));
+  return writeTurtle(quads, { prefixes: writerPrefixes() });
+}

package/scripts/lib/build-activity-turtle.mjs

@@ -1,92 +1,26 @@
-const PREFIXES = [
-  ['prov',    'http://www.w3.org/ns/prov#'],
-  ['dcterms', 'http://purl.org/dc/terms/'],
-  ['foaf',    'http://xmlns.com/foaf/0.1/'],
-  ['rdf',     'http://www.w3.org/1999/02/22-rdf-syntax-ns#'],
-  ['rdfs',    'http://www.w3.org/2000/01/rdf-schema#'],
-  ['xsd',     'http://www.w3.org/2001/XMLSchema#'],
-  ['gloss',   'https://www.glossarist.org/ontologies/'],
-];
-
-function ttlLit(s) {
-  if (s == null) return '""';
-  const escaped = String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-  return `"${escaped}"`;
+// Build activity turtle builder — emits prov:Activity per CI build run.
+//
+// Delegates to glossarist-js's build-activity emitter + writeTurtle.
+
+import {
+  buildActivityToQuads,
+  collectQuads,
+  writeTurtle,
+} from 'glossarist/rdf';
+
+function writerPrefixes() {
+  return {
+    prov: 'http://www.w3.org/ns/prov#',
+    dcterms: 'http://purl.org/dc/terms/',
+    foaf: 'http://xmlns.com/foaf/0.1/',
+    rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+    xsd: 'http://www.w3.org/2001/XMLSchema#',
+    gloss: 'https://www.glossarist.org/ontologies/',
+  };
 }
 
-export function buildActivityTurtle(input) {
-  const lines = [];
-  for (const [prefix, iri] of PREFIXES) {
-    lines.push(`@prefix ${prefix}: <${iri}> .`);
-  }
-  lines.push('');
-
-  const activityIri = `https://glossarist.org/activity/build/${input.runId}`;
-  const usedEntities = [];
-
-  if (input.gitSha) {
-    usedEntities.push({
-      iri: `https://glossarist.org/commit/${input.gitSha}`,
-      types: ['prov:Entity'],
-      label: input.gitSha,
-      extras: input.gitBranch ? [`dcterms:description ${ttlLit(`branch: ${input.gitBranch}`)}`] : [],
-    });
-  }
-
-  usedEntities.push({
-    iri: `https://glossarist.org/tool/${input.toolId}/${input.toolVersion}`,
-    types: ['prov:Entity', 'prov:SoftwareAgent'],
-    label: `${input.toolId} ${input.toolVersion}`,
-    extras: [
-      `dcterms:identifier ${ttlLit(input.toolVersion)}`,
-      `prov:version ${ttlLit(input.toolVersion)}`,
-    ],
-  });
-
-  for (const register of input.datasetRegisters ?? []) {
-    usedEntities.push({
-      iri: `https://glossarist.org/${register}/`,
-      types: ['prov:Entity'],
-      label: register,
-      extras: [],
-    });
-  }
-
-  const activityLines = [
-    `<${activityIri}> a prov:Activity ;`,
-    `  rdfs:label ${ttlLit(`build ${input.runId}`)} ;`,
-    `  prov:generatedAtTime "${input.endedAt}"^^xsd:dateTime ;`,
-  ];
-  for (const ent of usedEntities) {
-    activityLines.push(`  prov:used <${ent.iri}> ;`);
-  }
-  activityLines.push(`  gloss:conceptCount "${input.conceptCount}"^^xsd:integer ;`);
-  if (input.associatedAgentIri) {
-    activityLines.push(`  prov:wasAssociatedWith <${input.associatedAgentIri}> ;`);
-  }
-  activityLines[activityLines.length - 1] = activityLines[activityLines.length - 1].replace(/ ;$/, ' .');
-  lines.push(...activityLines);
-  lines.push('');
-
-  for (const ent of usedEntities) {
-    const entLines = [
-      `<${ent.iri}> a ${ent.types.join(', ')} ;`,
-      `  rdfs:label ${ttlLit(ent.label)}${ent.extras.length > 0 ? ' ;' : ' .'}`,
-    ];
-    for (let i = 0; i < ent.extras.length; i++) {
-      const last = i === ent.extras.length - 1;
-      entLines.push(`  ${ent.extras[i]}${last ? ' .' : ' ;'}`);
-    }
-    lines.push(...entLines);
-    lines.push('');
-  }
-
-  if (input.associatedAgentIri) {
-    const label = input.associatedAgentIri.split('/').pop() ?? 'agent';
-    lines.push(`<${input.associatedAgentIri}> a prov:Agent, foaf:Person ;`);
-    lines.push(`  rdfs:label ${ttlLit(label)} .`);
-    lines.push('');
-  }
-
-  return lines.join('\n') + '\n';
+export async function buildActivityTurtle(input) {
+  const quads = collectQuads(buildActivityToQuads(input));
+  return writeTurtle(quads, { prefixes: writerPrefixes() });
 }

package/scripts/lib/dataset-turtle.mjs

@@ -1,79 +1,33 @@
-const PREFIXES = [
-  ['dcat',     'http://www.w3.org/ns/dcat#'],
-  ['skos',     'http://www.w3.org/2004/02/skos/core#'],
-  ['dcterms',  'http://purl.org/dc/terms/'],
-  ['rdf',      'http://www.w3.org/1999/02/22-rdf-syntax-ns#'],
-  ['rdfs',     'http://www.w3.org/2000/01/rdf-schema#'],
-  ['prov',     'http://www.w3.org/ns/prov#'],
-  ['xsd',      'http://www.w3.org/2001/XMLSchema#'],
-];
-
-function ttlLit(s) {
-  if (s == null) return '""';
-  const escaped = String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-  return `"${escaped}"`;
+// Dataset turtle builder — emits dcat:Dataset + skos:ConceptScheme per
+// register.
+//
+// Delegates to glossarist-js's dataset emitter + writeTurtle so the
+// canonical prefix list, CURIE handling, and serialization stay in one
+// place.
+
+import {
+  datasetToQuads,
+  collectQuads,
+  writeTurtle,
+  PREFIXES,
+} from 'glossarist/rdf';
+
+function writerPrefixes() {
+  const out = {};
+  // Only the prefixes this emitter actually uses — keeps the output
+  // header focused.
+  for (const k of ['dcat', 'skos', 'dcterms', 'prov', 'rdf', 'rdfs', 'xsd']) {
+    if (PREFIXES[k]) out[k] = PREFIXES[k];
+  }
+  // dcat/prov are absent from glossarist-js's PREFIXES (which is
+  // generated from the JSON-LD context). Add them locally — they're
+  // in concept-model/prefixes.ttl.
+  out.dcat ??= 'http://www.w3.org/ns/dcat#';
+  out.prov ??= 'http://www.w3.org/ns/prov#';
+  return out;
 }
 
-export function buildDatasetTurtle(input) {
-  const lines = [];
-  for (const [prefix, iri] of PREFIXES) {
-    lines.push(`@prefix ${prefix}: <${iri}> .`);
-  }
-  lines.push('');
-
-  lines.push(`<${input.datasetIri}> a dcat:Dataset, skos:ConceptScheme ;`);
-  lines.push(`  dcterms:title ${ttlLit(input.title)} ;`);
-  if (input.description) {
-    lines.push(`  dcterms:description ${ttlLit(input.description)} ;`);
-  }
-  lines.push(`  dcterms:modified "${input.modified}"^^xsd:date ;`);
-  lines.push(`  dcterms:identifier ${ttlLit(input.registerId)} ;`);
-
-  for (const lang of input.languages ?? []) {
-    lines.push(`  dcterms:language <http://id.loc.gov/vocabulary/iso639-1/${lang}> ;`);
-  }
-
-  for (const dist of input.distributions ?? []) {
-    lines.push('  dcat:distribution [');
-    lines.push(`    a dcat:Distribution ;`);
-    lines.push(`    dcterms:title ${ttlLit(dist.title)} ;`);
-    lines.push(`    dcat:mediaType ${ttlLit(dist.mediaType)} ;`);
-    lines.push(`    dcat:downloadURL <${dist.downloadUrl}> ;`);
-    if (dist.byteSize != null) {
-      lines.push(`    dcat:byteSize "${dist.byteSize}"^^xsd:integer ;`);
-    }
-    lines.push('  ] ;');
-  }
-
-  for (const concept of input.topConceptUris ?? []) {
-    lines.push(`  skos:hasTopConcept <${concept}> ;`);
-  }
-
-  if (input.sourceRepoUrl) {
-    lines.push(`  prov:wasDerivedFrom <${input.sourceRepoUrl}> ;`);
-  }
-  if (input.publisherIri) {
-    lines.push(`  dcterms:publisher <${input.publisherIri}> ;`);
-  }
-  if (input.contactIri) {
-    lines.push(`  dcat:contactPoint <${input.contactIri}> ;`);
-  }
-
-  lines[lines.length - 1] = lines[lines.length - 1].replace(/ ;$/, ' .');
-
-  for (const section of input.sections ?? []) {
-    lines.push('');
-    lines.push(`<${section.collectionIri}> a skos:Collection ;`);
-    lines.push(`  dcterms:title ${ttlLit(section.title)} ;`);
-    for (const member of section.memberUris) {
-      lines.push(`  skos:member <${member}> ;`);
-    }
-    if (section.memberUris.length === 0) {
-      lines[lines.length - 1] = lines[lines.length - 1].replace(/ ;$/, ' .');
-    } else {
-      lines[lines.length - 1] = lines[lines.length - 1].replace(/ ;$/, ' .');
-    }
-  }
-
-  return lines.join('\n') + '\n';
+export async function buildDatasetTurtle(input) {
+  const quads = collectQuads(datasetToQuads(input));
+  return writeTurtle(quads, { prefixes: writerPrefixes() });
 }

package/scripts/lib/version-turtle.mjs

@@ -1,56 +1,29 @@
-const PREFIXES = [
-  ['prov',    'http://www.w3.org/ns/prov#'],
-  ['dcterms', 'http://purl.org/dc/terms/'],
-  ['rdfs',    'http://www.w3.org/2000/01/rdf-schema#'],
-  ['xsd',     'http://www.w3.org/2001/XMLSchema#'],
-];
+// Version turtle builder — emits prov:Entity version chain per dataset.
+//
+// Delegates to glossarist-js's version emitter + writeTurtle.
 
-function ttlLit(s) {
-  if (s == null) return '""';
-  const escaped = String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-  return `"${escaped}"`;
-}
+import {
+  versionToQuads,
+  versionHistoryToQuads,
+  collectQuads,
+  writeTurtle,
+} from 'glossarist/rdf';
 
-export function buildVersionTurtle(input) {
-  const lines = [];
-  for (const [prefix, iri] of PREFIXES) {
-    lines.push(`@prefix ${prefix}: <${iri}> .`);
-  }
-  lines.push('');
+function writerPrefixes() {
+  return {
+    prov: 'http://www.w3.org/ns/prov#',
+    dcterms: 'http://purl.org/dc/terms/',
+    rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+    xsd: 'http://www.w3.org/2001/XMLSchema#',
+  };
+}
 
-  lines.push(`<${input.versionIri}> a prov:Entity ;`);
-  lines.push(`  rdfs:label ${ttlLit(`${input.registerId} version ${input.version}`)} ;`);
-  lines.push(`  dcterms:isVersionOf <${input.datasetIri}> ;`);
-  if (input.previousVersionIri) {
-    lines.push(`  prov:wasRevisionOf <${input.previousVersionIri}> ;`);
-  }
-  lines.push(`  prov:generatedAtTime "${input.generatedAt}"^^xsd:dateTime ;`);
-  if (input.changeSummary) {
-    lines.push(`  dcterms:description ${ttlLit(input.changeSummary)} ;`);
-  }
-  if (input.associatedAgentIri) {
-    lines.push(`  prov:wasAssociatedWith <${input.associatedAgentIri}> ;`);
-  }
-  lines[lines.length - 1] = lines[lines.length - 1].replace(/ ;$/, ' .');
-  return lines.join('\n') + '\n';
+export async function buildVersionTurtle(input) {
+  const quads = collectQuads(versionToQuads(input));
+  return writeTurtle(quads, { prefixes: writerPrefixes() });
 }
 
-export function buildVersionHistoryTurtle(input) {
-  let previousIri;
-  const blocks = [];
-  for (const v of input.versions ?? []) {
-    const versionIri = `${input.datasetIri}versions/${v.version}`;
-    blocks.push(buildVersionTurtle({
-      registerId: input.registerId,
-      version: v.version,
-      versionIri,
-      datasetIri: input.datasetIri,
-      generatedAt: v.generatedAt,
-      previousVersionIri: previousIri,
-      changeSummary: v.changeSummary,
-      associatedAgentIri: input.associatedAgentIri,
-    }));
-    previousIri = versionIri;
-  }
-  return blocks.join('\n');
-}
+export async function buildVersionHistoryTurtle(input) {
+  const quads = collectQuads(versionHistoryToQuads(input));
+  return writeTurtle(quads, { prefixes: writerPrefixes() });
+}

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

@@ -15,14 +15,14 @@ const DCTERMS = 'http://purl.org/dc/terms/';
 const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
 
 describe('buildAgentsTurtle (mjs)', () => {
-  it('parses without errors', () => {
-    const ttl = buildAgentsTurtle([{ name: 'Ada Lovelace' }]);
+  it('parses without errors', async () => {
+    const ttl = await buildAgentsTurtle([{ name: 'Ada Lovelace' }]);
     const store = parse(ttl);
     expect(store.size).toBeGreaterThan(0);
   });
 
-  it('types each person as foaf:Person, prov:Person, prov:Agent', () => {
-    const ttl = buildAgentsTurtle([{ name: 'Ada Lovelace' }]);
+  it('types each person as foaf:Person, prov:Person, prov:Agent', async () => {
+    const ttl = await buildAgentsTurtle([{ name: 'Ada Lovelace' }]);
     const store = parse(ttl);
     const types = store.getObjects('https://glossarist.org/agent/ada-lovelace', RDF_TYPE, null).map(q => q.value);
     expect(types).toContain(`${FOAF}Person`);
@@ -30,8 +30,8 @@ describe('buildAgentsTurtle (mjs)', () => {
     expect(types).toContain(`${PROV}Agent`);
   });
 
-  it('records name, mailto mbox, role, and seeAlso', () => {
-    const ttl = buildAgentsTurtle([
+  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' },
     ]);
     const store = parse(ttl);
@@ -42,8 +42,8 @@ describe('buildAgentsTurtle (mjs)', () => {
     expect(store.getObjects(iri, 'http://www.w3.org/2000/01/rdf-schema#seeAlso', null).map(q => q.value)).toContain('https://example.org/ada');
   });
 
-  it('creates a single prov:Organization per unique organization', () => {
-    const ttl = buildAgentsTurtle([
+  it('creates a single prov:Organization per unique organization', async () => {
+    const ttl = await buildAgentsTurtle([
       { name: 'Alice', organization: 'ISO' },
       { name: 'Bob',   organization: 'ISO' },
     ]);
@@ -53,9 +53,9 @@ describe('buildAgentsTurtle (mjs)', () => {
     expect(types).toContain(`${PROV}Organization`);
   });
 
-  it('emits only prefix declarations for an empty input', () => {
-    const ttl = buildAgentsTurtle([]);
+  it('emits only prefix declarations for an empty input', async () => {
+    const ttl = await buildAgentsTurtle([]);
     expect(ttl).toContain('@prefix foaf:');
     expect(ttl).not.toContain('<https://glossarist.org/agent/');
   });
-});
+});

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

@@ -14,21 +14,21 @@ function parse(turtle: string): Store {
 }
 
 describe('buildBibliographyTurtle (mjs)', () => {
-  it('parses without errors', () => {
-    const ttl = buildBibliographyTurtle('iso-geodetic', { iso704: { reference: 'ISO 704' } });
+  it('parses without errors', async () => {
+    const ttl = await buildBibliographyTurtle('iso-geodetic', { iso704: { reference: 'ISO 704' } });
     const store = parse(ttl);
     expect(store.size).toBeGreaterThan(0);
   });
 
-  it('types each entry as dcterms:BibliographicResource', () => {
-    const ttl = buildBibliographyTurtle('iso-geodetic', { iso704: { reference: 'ISO 704' } });
+  it('types each entry as dcterms:BibliographicResource', async () => {
+    const ttl = await buildBibliographyTurtle('iso-geodetic', { iso704: { reference: 'ISO 704' } });
     const store = parse(ttl);
     const types = store.getObjects('https://glossarist.org/iso-geodetic/bib/iso704', RDF_TYPE, null).map(q => q.value);
     expect(types).toContain(`${DCTERMS}BibliographicResource`);
   });
 
-  it('emits identifier, bibliographicCitation, and title', () => {
-    const ttl = buildBibliographyTurtle('iso-geodetic', {
+  it('emits identifier, bibliographicCitation, and title', async () => {
+    const ttl = await buildBibliographyTurtle('iso-geodetic', {
       iso704: { reference: 'ISO 704', title: 'Terminology work — Principles and methods' },
     });
     const store = parse(ttl);
@@ -38,8 +38,8 @@ describe('buildBibliographyTurtle (mjs)', () => {
     expect(store.getObjects(iri, `${DCTERMS}title`, null).map(q => q.value)).toContain('Terminology work — Principles and methods');
   });
 
-  it('emits foaf:page when link is provided', () => {
-    const ttl = buildBibliographyTurtle('iso-geodetic', {
+  it('emits foaf:page when link is provided', async () => {
+    const ttl = await buildBibliographyTurtle('iso-geodetic', {
       ref: { reference: 'X', link: 'https://example.org/x' },
     });
     const store = parse(ttl);
@@ -47,8 +47,8 @@ describe('buildBibliographyTurtle (mjs)', () => {
     expect(store.getObjects(iri, `${FOAF}page`, null).map(q => q.value)).toContain('https://example.org/x');
   });
 
-  it('emits one resource per bibliography entry', () => {
-    const ttl = buildBibliographyTurtle('iso-geodetic', {
+  it('emits one resource per bibliography entry', async () => {
+    const ttl = await buildBibliographyTurtle('iso-geodetic', {
       a: { reference: 'A' },
       b: { reference: 'B' },
     });
@@ -56,4 +56,4 @@ describe('buildBibliographyTurtle (mjs)', () => {
     expect(store.getObjects('https://glossarist.org/iso-geodetic/bib/a', `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('A');
     expect(store.getObjects('https://glossarist.org/iso-geodetic/bib/b', `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('B');
   });
-});
+});

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

@@ -36,39 +36,39 @@ const expand = (v: string): string => {
 };
 
 describe('buildActivityTurtle (mjs)', () => {
-  it('parses without errors', () => {
-    const ttl = buildActivityTurtle(makeInput());
+  it('parses without errors', async () => {
+    const ttl = await buildActivityTurtle(makeInput());
     const store = parse(ttl);
     expect(store.size).toBeGreaterThan(0);
   });
 
-  it('types the activity as prov:Activity', () => {
+  it('types the activity as prov:Activity', async () => {
     const input = makeInput();
-    const store = parse(buildActivityTurtle(input));
+    const store = parse(await 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', () => {
+  it('records git commit and tool as prov:used', async () => {
     const input = makeInput();
-    const store = parse(buildActivityTurtle(input));
+    const store = parse(await 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', () => {
+  it('references every dataset register via prov:used', async () => {
     const input = makeInput({ datasetRegisters: ['a', 'b', 'c'] });
-    const store = parse(buildActivityTurtle(input));
+    const store = parse(await 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', () => {
+  it('associates the CI agent when provided', async () => {
     const input = makeInput();
-    const store = parse(buildActivityTurtle(input));
+    const store = parse(await 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-integration.test.ts

@@ -27,7 +27,7 @@ describe('WS F Layer 8 — build pipeline integration', () => {
   it('dataset-turtle.mjs produces parseable dcat:Dataset', () => {
     const out = runInline(`
       import { buildDatasetTurtle } from './scripts/lib/dataset-turtle.mjs';
-      console.log(buildDatasetTurtle({
+      console.log(await buildDatasetTurtle({
         datasetIri: 'https://glossarist.org/test/',
         registerId: 'test', title: 'Test', modified: '2026-06-28',
         languages: ['eng'], distributions: [], topConceptUris: [], sections: [],
@@ -45,7 +45,7 @@ describe('WS F Layer 8 — build pipeline integration', () => {
   it('build-activity-turtle.mjs produces parseable prov:Activity', () => {
     const out = runInline(`
       import { buildActivityTurtle } from './scripts/lib/build-activity-turtle.mjs';
-      console.log(buildActivityTurtle({
+      console.log(await buildActivityTurtle({
         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 +61,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(buildAgentsTurtle([{ name: 'Ada Lovelace', role: 'Editor', organization: 'Royal Society' }]));
+      console.log(await buildAgentsTurtle([{ name: 'Ada Lovelace', role: 'Editor', organization: 'Royal Society' }]));
     `);
     const store = parseTurtle(out);
     const persons = [...store].filter(q =>
@@ -74,7 +74,7 @@ describe('WS F Layer 8 — build pipeline integration', () => {
   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' } }));
+      console.log(await buildBibliographyTurtle('test', { iso704: { reference: 'ISO 704' } }));
     `);
     const store = parseTurtle(out);
     const bibs = [...store].filter(q =>
@@ -87,7 +87,7 @@ describe('WS F Layer 8 — build pipeline integration', () => {
   it('version-turtle.mjs produces parseable prov:Entity chain', () => {
     const out = runInline(`
       import { buildVersionHistoryTurtle } from './scripts/lib/version-turtle.mjs';
-      console.log(buildVersionHistoryTurtle({
+      console.log(await buildVersionHistoryTurtle({
         registerId: 'test', datasetIri: 'https://glossarist.org/test/',
         versions: [
           { version: '1.0', generatedAt: '2024-01-01T00:00:00Z' },
@@ -120,11 +120,11 @@ describe('WS F Layer 8 — build pipeline integration', () => {
       import { buildVersionHistoryTurtle } from './scripts/lib/version-turtle.mjs';
       const parts = [
         await 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' }] }),
+        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' }]),
+        await buildBibliographyTurtle('test', { x: { reference: 'X' } }),
+        await buildVersionHistoryTurtle({ registerId: 't', datasetIri: 'https://glossarist.org/t/', versions: [{ version: '1', generatedAt: '2026-01-01' }] }),
       ];
       console.log(parts.join('\\n'));
     `);

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

@@ -50,23 +50,23 @@ const expand = (v: string): string => {
 };
 
 describe('buildDatasetTurtle (mjs)', () => {
-  it('parses without errors and produces a non-empty graph', () => {
-    const ttl = buildDatasetTurtle(makeInput());
+  it('parses without errors and produces a non-empty graph', async () => {
+    const ttl = await buildDatasetTurtle(makeInput());
     const store = parse(ttl);
     expect(store.size).toBeGreaterThan(0);
   });
 
-  it('types the dataset as dcat:Dataset and skos:ConceptScheme', () => {
+  it('types the dataset as dcat:Dataset and skos:ConceptScheme', async () => {
     const input = makeInput();
-    const store = parse(buildDatasetTurtle(input));
+    const store = parse(await 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', () => {
+  it('emits a dcat:Distribution blank per distribution', async () => {
     const input = makeInput();
-    const store = parse(buildDatasetTurtle(input));
+    const store = parse(await 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);
@@ -75,9 +75,9 @@ describe('buildDatasetTurtle (mjs)', () => {
     expect(byteSizes).toContain('12345');
   });
 
-  it('emits skos:Collection per section with skos:member entries', () => {
+  it('emits skos:Collection per section with skos:member entries', async () => {
     const input = makeInput();
-    const store = parse(buildDatasetTurtle(input));
+    const store = parse(await 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'));
@@ -85,9 +85,9 @@ describe('buildDatasetTurtle (mjs)', () => {
     expect(members).toContain(`${BASE}/test/concept/1`);
   });
 
-  it('escapes double-quotes and backslashes in titles', () => {
+  it('escapes double-quotes and backslashes in titles', async () => {
     const input = makeInput({ title: 'has "quotes" and back\\slash' });
-    const store = parse(buildDatasetTurtle(input));
+    const store = parse(await 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/version-turtle.test.ts

@@ -14,8 +14,8 @@ 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({
+  it('parses without errors', async () => {
+    const ttl = await buildVersionTurtle({
       registerId: 'test',
       version: '1.0',
       versionIri: 'https://glossarist.org/test/versions/1.0',
@@ -26,8 +26,8 @@ describe('buildVersionTurtle (mjs)', () => {
     expect(store.size).toBeGreaterThan(0);
   });
 
-  it('types the version as prov:Entity', () => {
-    const ttl = buildVersionTurtle({
+  it('types the version as prov:Entity', async () => {
+    const ttl = await buildVersionTurtle({
       registerId: 'test',
       version: '1.0',
       versionIri: 'https://glossarist.org/test/versions/1.0',
@@ -39,8 +39,8 @@ describe('buildVersionTurtle (mjs)', () => {
     expect(types).toContain(`${PROV}Entity`);
   });
 
-  it('emits prov:wasRevisionOf when a previous version is provided', () => {
-    const ttl = buildVersionTurtle({
+  it('emits prov:wasRevisionOf when a previous version is provided', async () => {
+    const ttl = await buildVersionTurtle({
       registerId: 'test',
       version: '1.0',
       versionIri: 'https://glossarist.org/test/versions/1.0',
@@ -55,8 +55,8 @@ describe('buildVersionTurtle (mjs)', () => {
 });
 
 describe('buildVersionHistoryTurtle (mjs)', () => {
-  it('emits a chain with revision links', () => {
-    const ttl = buildVersionHistoryTurtle({
+  it('emits a chain with revision links', async () => {
+    const ttl = await buildVersionHistoryTurtle({
       registerId: 'test',
       datasetIri: 'https://glossarist.org/test/',
       versions: [
@@ -69,4 +69,4 @@ describe('buildVersionHistoryTurtle (mjs)', () => {
     const prev = store.getObjects(iri11, `${PROV}wasRevisionOf`, null).map(q => q.value);
     expect(prev).toContain('https://glossarist.org/test/versions/1.0');
   });
-});
+});

package/src/config/group-types.ts

@@ -33,7 +33,7 @@ export const GROUP_TYPES: Record<DatasetGroupKind, GroupTypeMeta> = {
     kind: 'lineage',
     label: 'Edition series',
     description: 'Same vocabulary, different editions over time',
-    glyph: '⏳',
+    glyph: '⟶',
     ordered: true,
     supersession: true,
     sameVocabulary: true,

package/src/views/DatasetView.vue

@@ -2,6 +2,7 @@
 import { computed, ref, watch, onMounted, onUnmounted, onBeforeUnmount } from 'vue';
 import { useRoute, useRouter } from 'vue-router';
 import { useVocabularyStore } from '../stores/vocabulary';
+import { useUiStore } from '../stores/ui';
 import { useDsStyle } from '../utils/dataset-style';
 import { useDatasetLoader } from '../composables/use-dataset-loader';
 import { FORMAT_LABELS } from '../config/types';
@@ -17,6 +18,7 @@ import { formatSectionLabel } from '../utils/section-display';
 const props = defineProps<{ registerId: string }>();
 
 const store = useVocabularyStore();
+const uiStore = useUiStore();
 const { getStyle } = useDsStyle();
 const { ensureLoaded, loading, localError } = useDatasetLoader(() => props.registerId);
 const { t } = useI18n();
@@ -30,6 +32,16 @@ const localizedDescription = computed(() => localizedDatasetField(props.register
 const adapter = computed(() => store.datasets.get(props.registerId));
 const chunkLoading = ref(false);
 
+// Concept-count badge: tinted bg + always-readable text in either mode.
+// Previously used `.light` for bg and `.dark` for text — but `.dark` is
+// just `.light` with alpha, so text was invisible against the bg.
+const conceptCountBadgeStyle = computed(() => {
+  const s = getStyle(props.registerId);
+  return uiStore.isDark
+    ? { backgroundColor: s.darkAlpha(0.25), color: s.light }
+    : { backgroundColor: s.light, color: '#ffffff' };
+});
+
 // Background chunk preloading via requestIdleCallback
 let idlePreloadHandle: ReturnType<typeof requestIdleCallback> | ReturnType<typeof setTimeout> | null = null;
 
@@ -310,7 +322,7 @@ function clearSection() {
       <h1 class="font-serif text-3xl text-ink-800 mb-2">{{ localizedTitle }}</h1>
       <p class="text-ink-400 leading-relaxed max-w-2xl">{{ localizedDescription }}</p>
       <div class="flex flex-wrap gap-2 mt-4">
-        <span class="badge" :style="{ backgroundColor: getStyle(registerId).light, color: getStyle(registerId).dark }">{{ manifest.conceptCount.toLocaleString() }} {{ t('dataset.concepts') }}</span>
+        <span class="badge" :style="conceptCountBadgeStyle">{{ manifest.conceptCount.toLocaleString() }} {{ t('dataset.concepts') }}</span>
         <span class="badge badge-gray">{{ manifest.languages.length }} {{ t('dataset.languages') }}</span>
         <span class="badge badge-green">{{ manifest.owner }}</span>
         <router-link :to="{ name: 'stats', params: { registerId } }" class="badge badge-blue hover:opacity-80 transition-opacity">

package/src/views/HomeView.vue

@@ -1,6 +1,7 @@
 <script setup lang="ts">
 import { computed, ref } from 'vue';
 import { useVocabularyStore } from '../stores/vocabulary';
+import { useUiStore } from '../stores/ui';
 import { useRouter } from 'vue-router';
 import { useDsStyle } from '../utils/dataset-style';
 import { useSiteConfig } from '../config/use-site-config';
@@ -8,10 +9,18 @@ import { useI18n } from '../i18n';
 import HomeSeriesSection from '../components/HomeSeriesSection.vue';
 
 const store = useVocabularyStore();
+const uiStore = useUiStore();
 const router = useRouter();
 const { getStyle } = useDsStyle();
 const { config: siteConfig, localizedTitle, localizedSubtitle, localizedDescription, localizedDatasetField } = useSiteConfig();
 const { t } = useI18n();
+
+function tagBadgeStyle(dsId: string) {
+  const s = getStyle(dsId);
+  return uiStore.isDark
+    ? { backgroundColor: s.darkAlpha(0.25), color: s.light }
+    : { backgroundColor: s.light, color: '#ffffff' };
+}
 const exploring = ref(false);
 
 async function exploreRandom() {
@@ -181,7 +190,7 @@ function goToGraph() { router.push({ name: 'graph' }); }
           </div>
 
           <div class="flex flex-wrap gap-1.5 pl-[22px] mb-3">
-            <span v-for="tag in (ds.manifest.tags ?? []).slice(0, 3)" :key="tag" class="badge text-[10px]" :style="{ backgroundColor: getStyle(ds.id).light, color: getStyle(ds.id).dark }">
+            <span v-for="tag in (ds.manifest.tags ?? []).slice(0, 3)" :key="tag" class="badge text-[10px]" :style="tagBadgeStyle(ds.id)">
               {{ tag }}
             </span>
           </div>