@glossarist/concept-browser 0.7.61 → 0.7.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.61",
+  "version": "0.7.63",
   "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__/relation-sphere-uri.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { UriRouter } from '../adapters/UriRouter';
+
+describe('UriRouter.parseUri — deployment-agnostic concept URI parsing', () => {
+  // The old parseNeighborUri in RelationSphere.vue hardcoded specific
+  // hostnames. UriRouter.parseUri must work for ANY deployment.
+  const cases: Array<[string, string, string]> = [
+    // [input URI, expected registerId, expected conceptId]
+    ['https://www.glossarist.org/iala-vocab/iala-2022/concept/1-1-000',     'iala-2022', '1-1-000'],
+    ['https://glossarist.org/iala-2022/concept/1-1-000',                    'iala-2022', '1-1-000'],
+    ['https://glossarist.org/iso/concept/3.1.1',                            'iso',       '3.1.1'],
+    ['https://oimlsmart.github.io/vocab/viml-2022/concept/1.1',             'viml-2022', '1.1'],
+    ['https://www.oimlsmart.org/vocab/viml-2022/concept/1.1',               'viml-2022', '1.1'],
+    ['https://metanorma.github.io/iala-vocab/iala-2023/concept/2-1-245',    'iala-2023', '2-1-245'],
+    ['https://isotc204.geolexica.org/isotc204-2022/concept/3.5.8.8',       'isotc204-2022', '3.5.8.8'],
+    ['https://vocab.example.org/dataset-x/concept/foo',                      'dataset-x', 'foo'],
+    ['https://custom.host/path/to/register/concept/abc-123',                'register',  'abc-123'],
+  ];
+
+  for (const [uri, expectedReg, expectedId] of cases) {
+    it(`parses ${uri}`, () => {
+      const parsed = UriRouter.parseUri(uri);
+      expect(parsed).toEqual({ registerId: expectedReg, conceptId: expectedId });
+    });
+  }
+
+  it('returns null for URIs without /concept/', () => {
+    expect(UriRouter.parseUri('https://example.org/foo/bar')).toBeNull();
+    expect(UriRouter.parseUri('urn:iso:std:iso:14812:2025:3.5.8.8')).toBeNull();
+    expect(UriRouter.parseUri('')).toBeNull();
+  });
+
+  it('does NOT hardcode any specific hostname', () => {
+    // Every deployment domain should work. If the regex hardcodes
+    // a specific host, this test would fail for others.
+    const diverse = [
+      'https://a.io/r/concept/1',
+      'https://b.com/x/y/z/concept/2',
+      'https://1.2.3.4/reg/concept/3',
+    ];
+    for (const uri of diverse) {
+      expect(UriRouter.parseUri(uri)).not.toBeNull();
+    }
+  });
+});

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/components/RelationSphere.vue

@@ -18,6 +18,7 @@ import { useDsStyle } from '../utils/dataset-style';
 import { getFactory } from '../adapters/factory';
 import { SPHERE_RELATION_CATEGORIES as RELATION_CATEGORIES, sphereCategoryForType as categoryForType, categorizeRelationForSphere as categorizeRelation, colorForTypeInMode as colorForTypeRaw, relationLabel as relationTypeLabel } from '../utils/relation-sphere-styling';
 import { easeInOutCubic, slerp, fibonacciSpherePosition, project, cardEdge, type Vec3 } from '../composables/useSphereProjection';
+import { UriRouter } from '../adapters/UriRouter';
 import { getPreferredTerm } from '../utils/concept-helpers';
 import { renderContent } from '../utils/content-renderer';
 import { useI18n } from '../i18n';
@@ -226,14 +227,6 @@ function updateNodeTerm(n: SNode) {
 }
 
 /* ── Build internal graph from concept + edges (BFS) ────── */
-function parseNeighborUri(uri: string, fallbackReg: string): { register: string; conceptId: string } | null {
-  const m = uri.match(/(?:glossarist\.org|oimlsmart\.github\.io\/vocab)\/([^/]+)\/concept\/([^/?#]+)/);
-  if (m) return { register: m[1], conceptId: m[2] };
-  /* URN or other shape — use fallback register, last path segment as id */
-  const parts = uri.split('/').filter(Boolean);
-  if (parts.length === 0) return null;
-  return { register: fallbackReg, conceptId: parts[parts.length - 1] };
-}
 
 function hashSeed(s: string): number {
   let h = 0;
@@ -280,12 +273,12 @@ function buildGraph() {
 
   /* First pass: collect depth-1 neighbors (deduped) so we know N for even
      ring placement. */
-  const depth1List: Array<{ uri: string; parsed: { register: string; conceptId: string }; isOutgoing: boolean; edge: GraphEdge }> = [];
+  const depth1List: Array<{ uri: string; parsed: { registerId: string; conceptId: string }; isOutgoing: boolean; edge: GraphEdge }> = [];
   for (const edge of props.edges) {
     const isOutgoing = edge.source === focusUri || edge.source === focusId;
     const otherUri = isOutgoing ? edge.target : edge.source;
     if (!otherUri || visited.has(otherUri)) continue;
-    const parsed = parseNeighborUri(otherUri, edge.register || props.registerId);
+    const parsed = UriRouter.parseUri(otherUri);
     if (!parsed || parsed.conceptId === focusId) continue;
     visited.set(otherUri, 1);
     depth1List.push({ uri: otherUri, parsed, isOutgoing, edge });
@@ -298,8 +291,8 @@ function buildGraph() {
     nodeMap.set(parsed.conceptId, {
       id: parsed.conceptId,
       term: edge.label || parsed.conceptId,
-      ref: parsed.register,
-      register: parsed.register,
+      ref: parsed.registerId,
+      register: parsed.registerId,
       conceptId: parsed.conceptId,
       depth: 1,
       x: pos.x, y: pos.y, z: pos.z,
@@ -331,13 +324,13 @@ function buildGraph() {
     const inEdges = store.graph.getIncomingEdges(uri);
     /* Collect this node's children first so we can place them as an even
        sub-ring around their parent. */
-    const children: Array<{ uri: string; parsed: { register: string; conceptId: string }; isOutgoing: boolean; edge: GraphEdge }> = [];
+    const children: Array<{ uri: string; parsed: { registerId: string; conceptId: string }; isOutgoing: boolean; edge: GraphEdge }> = [];
     for (const edge of [...outEdges, ...inEdges]) {
       if (nodeMap.size + children.length >= MAX_NODES) break;
       const isOutgoing = edge.source === uri;
       const otherUri = isOutgoing ? edge.target : edge.source;
       if (!otherUri || visited.has(otherUri)) continue;
-      const parsed = parseNeighborUri(otherUri, edge.register || props.registerId);
+      const parsed = UriRouter.parseUri(otherUri);
       if (!parsed || parsed.conceptId === focusId || nodeMap.has(parsed.conceptId)) continue;
       visited.set(otherUri, depth + 1);
       children.push({ uri: otherUri, parsed, isOutgoing, edge });
@@ -347,8 +340,8 @@ function buildGraph() {
       nodeMap.set(parsed.conceptId, {
         id: parsed.conceptId,
         term: parsed.conceptId,
-        ref: parsed.register,
-        register: parsed.register,
+        ref: parsed.registerId,
+        register: parsed.registerId,
         conceptId: parsed.conceptId,
         depth: depth + 1,
         x: pos.x, y: pos.y, z: pos.z,