@glossarist/concept-browser 0.7.135 → 0.7.137

package/scripts/doctor.ts

@@ -22,7 +22,9 @@ export const NODE_MIN_MAJOR = 18;
 /**
  * @typedef {'pass'|'fail'|'warn'} CheckStatus
  * @typedef {{ id: string, label: string, status: CheckStatus, detail?: string, hint?: string }} CheckResult
- * @typedef {{ cwd: string, pkgRoot: string, datasetsYml?: any, datasetsYmlError?: string }} DoctorContext
+ * @typedef {{ id: string, localPath?: string }} RegisteredDataset
+ * @typedef {{ registered: RegisteredDataset[], source: 'datasets.yml'|'site-config.yml'|null, error?: string }} DatasetRegistry
+ * @typedef {{ cwd: string, pkgRoot: string, datasetsYml?: any, datasetsYmlError?: string, registry: DatasetRegistry }} DoctorContext
  */
 
 /**
@@ -63,8 +65,12 @@ function nodeVersionCheck() {
 }
 
 function packageDepsCheck(ctx) {
-  const nm = resolve(ctx.pkgRoot, 'node_modules');
-  if (!existsSync(nm)) {
+  // When installed as a library, the CLI's deps may be hoisted into the
+  // consumer's node_modules or nested under the package's own — accept
+  // either. Checking only PKG_ROOT (the installed package dir) reported
+  // false "node_modules missing" in consumer deployments.
+  const roots = [resolve(ctx.cwd, 'node_modules'), resolve(ctx.pkgRoot, 'node_modules')];
+  if (!roots.some((nm) => existsSync(nm))) {
     return {
       id: 'package-deps',
       label: 'Dependencies installed',
@@ -74,7 +80,7 @@ function packageDepsCheck(ctx) {
     };
   }
   const required = ['vue', 'vue-router', 'pinia', 'vite', 'n3', 'glossarist', '@rdfjs/dataset'];
-  const missing = required.filter((p) => !existsSync(join(nm, p)));
+  const missing = required.filter((p) => !roots.some((nm) => existsSync(join(nm, p))));
   if (missing.length) {
     return {
       id: 'package-deps',
@@ -87,67 +93,103 @@ function packageDepsCheck(ctx) {
   return { id: 'package-deps', label: 'Dependencies installed', status: 'pass' };
 }
 
-function datasetsYmlCheck(ctx) {
-  const path = resolve(ctx.cwd, 'datasets.yml');
-  if (!existsSync(path)) {
-    return {
-      id: 'datasets-yml',
-      label: 'datasets.yml present',
-      status: 'warn',
-      detail: 'file not found at project root',
-      hint: 'datasets.yml registers every dataset the browser serves',
-    };
+/**
+ * Dataset registrations come from either `datasets.yml` (source repos to
+ * fetch) or `site-config.yml` (deployment sites, entries carry
+ * `local_path` to in-repo YAML). Doctor only knew the former, so
+ * site-config deployments reported "no datasets registered".
+ * @returns {{ registered: Array<{id: string, localPath?: string}>, source: 'datasets.yml'|'site-config.yml'|null, error?: string }}
+ */
+export function resolveDatasetRegistry(cwd, fileError = undefined) {
+  if (fileError) return { registered: [], source: 'datasets.yml', error: fileError };
+  const ymlPath = resolve(cwd, 'datasets.yml');
+  if (existsSync(ymlPath)) {
+    const list = normalizeRegistry(yaml.load(readFileSync(ymlPath, 'utf8')));
+    return { registered: list, source: 'datasets.yml' };
+  }
+  const sitePath = resolve(cwd, 'site-config.yml');
+  if (existsSync(sitePath)) {
+    try {
+      const list = normalizeRegistry(yaml.load(readFileSync(sitePath, 'utf8')));
+      return { registered: list, source: 'site-config.yml' };
+    } catch (err) {
+      return { registered: [], source: 'site-config.yml', error: err.message };
+    }
   }
-  if (ctx.datasetsYmlError) {
+  return { registered: [], source: null };
+}
+
+function normalizeRegistry(doc) {
+  const datasets = doc?.datasets;
+  if (!Array.isArray(datasets)) return [];
+  return datasets
+    .filter((d) => d && typeof d === 'object' && d.id)
+    .map((d) => ({ id: String(d.id), localPath: d.local_path ?? d.localPath }));
+}
+
+function datasetsRegisteredCheck(ctx) {
+  if (ctx.registry.error) {
     return {
-      id: 'datasets-yml',
-      label: 'datasets.yml parses',
+      id: 'datasets-registered',
+      label: `${ctx.registry.source} parses`,
       status: 'fail',
-      detail: ctx.datasetsYmlError,
+      detail: ctx.registry.error,
       hint: 'fix the YAML syntax error',
     };
   }
-  const datasets = ctx.datasetsYml?.datasets;
-  if (!Array.isArray(datasets) || datasets.length === 0) {
+  if (!ctx.registry.source) {
     return {
-      id: 'datasets-yml',
-      label: 'datasets.yml lists datasets',
+      id: 'datasets-registered',
+      label: 'Dataset registry present',
       status: 'warn',
-      detail: '`datasets` key is empty or missing',
+      detail: 'neither datasets.yml nor site-config.yml found at project root',
+      hint: 'datasets.yml / site-config.yml register every dataset the browser serves',
+    };
+  }
+  if (ctx.registry.registered.length === 0) {
+    return {
+      id: 'datasets-registered',
+      label: 'Dataset registry lists datasets',
+      status: 'warn',
+      detail: `\`datasets\` key is empty or missing in ${ctx.registry.source}`,
       hint: 'add at least one dataset entry; see docs/adding-a-dataset.md',
     };
   }
   return {
-    id: 'datasets-yml',
-    label: `datasets.yml lists ${datasets.length} dataset(s)`,
+    id: 'datasets-registered',
+    label: `${ctx.registry.source} lists ${ctx.registry.registered.length} dataset(s)`,
     status: 'pass',
   };
 }
 
 function datasetsFetchedCheck(ctx) {
-  const datasets = ctx.datasetsYml?.datasets ?? [];
-  if (!datasets.length) {
+  const datasets = ctx.registry.registered;
+  if (!ctx.registry.source || !datasets.length) {
     return { id: 'datasets-fetched', label: 'Source datasets fetched', status: 'warn', detail: 'no datasets registered' };
   }
-  const dotDatasets = resolve(ctx.cwd, '.datasets');
+  // site-config deployments keep sources in-repo at local_path; the
+  // datasets.yml flow fetches source repos into .datasets/{id}/concepts.
   const missing = datasets
-    .filter((d) => !existsSync(join(dotDatasets, d.id, 'concepts')))
+    .filter((d) => {
+      if (d.localPath) return !existsSync(resolve(ctx.cwd, d.localPath));
+      return !existsSync(join(resolve(ctx.cwd, '.datasets'), d.id, 'concepts'));
+    })
     .map((d) => d.id);
   if (missing.length) {
     return {
       id: 'datasets-fetched',
       label: 'Source datasets fetched',
       status: 'fail',
-      detail: `.datasets/ missing: ${missing.join(', ')}`,
-      hint: 'run `npm run fetch-datasets`',
+      detail: `dataset sources missing: ${missing.join(', ')}`,
+      hint: 'run `npm run fetch-datasets` (or check local_path entries in site-config.yml)',
     };
   }
   return { id: 'datasets-fetched', label: 'Source datasets fetched', status: 'pass' };
 }
 
 function datasetsGeneratedCheck(ctx) {
-  const datasets = ctx.datasetsYml?.datasets ?? [];
-  if (!datasets.length) {
+  const datasets = ctx.registry.registered;
+  if (!ctx.registry.source || !datasets.length) {
     return { id: 'datasets-generated', label: 'Generated data present', status: 'warn', detail: 'no datasets registered' };
   }
   const publicData = resolve(ctx.cwd, 'public', 'data');
@@ -256,7 +298,7 @@ function jsonldContextCheck(ctx) {
 export const CHECKS = [
   safe('node-version', nodeVersionCheck),
   safe('package-deps', packageDepsCheck),
-  safe('datasets-yml', datasetsYmlCheck),
+  safe('datasets-registered', datasetsRegisteredCheck),
   safe('datasets-fetched', datasetsFetchedCheck),
   safe('datasets-generated', datasetsGeneratedCheck),
   safe('public-datasets-json', publicDatasetsJsonCheck),
@@ -280,7 +322,13 @@ export async function runDoctor(cwd = process.cwd()) {
     }
   }
   /** @type {DoctorContext} */
-  const ctx = { cwd, pkgRoot: PKG_ROOT, datasetsYml, datasetsYmlError };
+  const ctx = {
+    cwd,
+    pkgRoot: PKG_ROOT,
+    datasetsYml,
+    datasetsYmlError,
+    registry: resolveDatasetRegistry(cwd, datasetsYmlError),
+  };
 
   const results = [];
   for (const check of CHECKS) {

package/scripts/generate-data.js

@@ -2,7 +2,16 @@
 import fs2 from "fs";
 import path3 from "path";
 import yaml4 from "js-yaml";
-import { naturalSort, Register, parseMentions, InvalidMentionError } from "glossarist";
+import {
+  naturalSort,
+  Register,
+  parseMentions,
+  InvalidMentionError,
+  parseConceptYaml,
+  conceptToTurtle,
+  conceptsToTbx,
+  emitOutputSet
+} from "glossarist";
 
 // scripts/load-site-config.ts
 import { readFileSync, existsSync } from "fs";
@@ -546,6 +555,9 @@ function normalizeBibliography(raw) {
 function buildConceptUri(uriBase, registerId, conceptId) {
   return `${uriBase}/dataset/${registerId}/concept/${conceptId}`;
 }
+function buildConceptUriPrefix(uriBase, registerId) {
+  return `${uriBase}/dataset/${registerId}/concept/`;
+}
 
 // scripts/lib/harmonize-concept.ts
 import fs from "fs";
@@ -782,301 +794,6 @@ function refsToJsonLd(refs, refMaps2) {
   }).filter((r) => r["@id"]);
 }
 
-// scripts/lib/turtle-escape.ts
-var STRING_ESCAPES = {
-  "\\": "\\\\",
-  '"': '\\"',
-  "\n": "\\n",
-  "\r": "\\r",
-  "	": "\\t"
-};
-function ttlLit(s) {
-  if (s == null) return '""';
-  const escaped = String(s).replace(/[\\\"\n\r\t]/g, (ch) => STRING_ESCAPES[ch] ?? ch);
-  return `"${escaped}"`;
-}
-
-// scripts/lib/concept-formats.ts
-function escapeTurtle(s) {
-  return ttlLit(s).slice(1, -1);
-}
-function escapeXml(s) {
-  const str = Array.isArray(s) ? s.join(", ") : String(s ?? "");
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function conceptJsonToTurtle(concept) {
-  const uri = concept["@id"] || "";
-  const id = concept["gl:identifier"] || "";
-  const lines = [
-    "@prefix skos: <http://www.w3.org/2004/02/skos/core#> .",
-    "@prefix dcterms: <http://purl.org/dc/terms/> .",
-    ""
-  ];
-  const props = ["  a skos:Concept"];
-  props.push(`  skos:notation "${escapeTurtle(id)}"`);
-  for (const [lang, lc] of Object.entries(concept["gl:localizedConcept"] || {})) {
-    if (lc["gl:designation"]) {
-      for (const d of lc["gl:designation"]) {
-        const term = d["gl:term"];
-        if (!term) continue;
-        const pred = d["gl:normativeStatus"] === "preferred" ? "skos:prefLabel" : "skos:altLabel";
-        props.push(`  ${pred} "${escapeTurtle(term)}"@${lang}`);
-      }
-    }
-    if (lc["gl:definition"]) {
-      for (const d of lc["gl:definition"]) {
-        if (d["gl:content"]) props.push(`  skos:definition "${escapeTurtle(d["gl:content"])}"@${lang}`);
-      }
-    }
-    if (lc["gl:notes"]) {
-      for (const d of lc["gl:notes"]) {
-        if (d["gl:content"]) props.push(`  skos:scopeNote "${escapeTurtle(d["gl:content"])}"@${lang}`);
-      }
-    }
-  }
-  lines.push(`<${uri}>`);
-  lines.push(props.join(" ;\n"));
-  lines.push(" .");
-  return lines.join("\n");
-}
-var SKOS_JSON_LD_CONTEXT = {
-  skos: "http://www.w3.org/2004/02/skos/core#",
-  dcterms: "http://purl.org/dc/terms/",
-  "@language": { "@container": "@language" }
-};
-function buildSkosJsonLdObject(concept) {
-  const uri = concept["@id"] || "";
-  const id = concept["gl:identifier"] || "";
-  const doc = {
-    "@id": uri,
-    "@type": "skos:Concept",
-    "skos:notation": id
-  };
-  const prefLabels = {};
-  const altLabels = {};
-  const definitions = {};
-  const scopeNotes = {};
-  for (const [lang, lc] of Object.entries(concept["gl:localizedConcept"] || {})) {
-    const descs = lc["gl:designation"] || [];
-    const pref = descs.find((d) => d["gl:normativeStatus"] === "preferred" && d["gl:term"]);
-    const alt = descs.find((d) => d["gl:normativeStatus"] !== "preferred" && d["gl:term"]);
-    if (pref) prefLabels[lang] = pref["gl:term"];
-    if (alt) altLabels[lang] = alt["gl:term"];
-    const def = (lc["gl:definition"] || [])[0];
-    if (def?.["gl:content"]) definitions[lang] = def["gl:content"];
-    const note = (lc["gl:notes"] || [])[0];
-    if (note?.["gl:content"]) scopeNotes[lang] = note["gl:content"];
-  }
-  if (Object.keys(prefLabels).length) doc["skos:prefLabel"] = prefLabels;
-  if (Object.keys(altLabels).length) doc["skos:altLabel"] = altLabels;
-  if (Object.keys(definitions).length) doc["skos:definition"] = definitions;
-  if (Object.keys(scopeNotes).length) doc["skos:scopeNote"] = scopeNotes;
-  return doc;
-}
-function conceptJsonToSkosJsonLd(concept) {
-  return JSON.stringify({
-    "@context": SKOS_JSON_LD_CONTEXT,
-    ...buildSkosJsonLdObject(concept)
-  });
-}
-function conceptsToSkosJsonLdGraph(concepts) {
-  return JSON.stringify(
-    {
-      "@context": SKOS_JSON_LD_CONTEXT,
-      "@graph": concepts.map(buildSkosJsonLdObject)
-    },
-    null,
-    2
-  );
-}
-var CSV_COLUMNS = [
-  "termid",
-  "uri",
-  "status",
-  "section",
-  "language",
-  "term",
-  "alt_terms",
-  "definition",
-  "notes",
-  "examples",
-  "sources",
-  "source_links"
-];
-function csvEscape(value) {
-  if (/[",\r\n]/.test(value)) {
-    return `"${value.replace(/"/g, '""')}"`;
-  }
-  return value;
-}
-function joinLines(items) {
-  return items.filter(Boolean).join("\n");
-}
-function localizedLanguages(localized, languageOrder) {
-  const present = Object.keys(localized);
-  if (!languageOrder?.length) return present;
-  const ordered = languageOrder.filter((lang) => present.includes(lang));
-  return ordered.concat(present.filter((lang) => !ordered.includes(lang)));
-}
-function sourceRefString(src) {
-  const ref = src?.["gl:origin"]?.["gl:ref"];
-  if (!ref) return "";
-  return [ref["gl:source"], ref["gl:id"]].filter(Boolean).join(": ");
-}
-function sourceLinkString(src) {
-  return src?.["gl:origin"]?.["gl:link"] || "";
-}
-function conceptsToCsv(concepts, opts = {}) {
-  const rows = [CSV_COLUMNS.join(",")];
-  for (const concept of concepts) {
-    const localized = concept["gl:localizedConcept"] || {};
-    const domains = (concept["gl:domain"] || []).map((d) => d["gl:conceptId"]).filter(Boolean).join("; ");
-    const managedSources = concept["gl:source"] || [];
-    const shared = {
-      termid: concept["gl:identifier"] || "",
-      uri: concept["@id"] || "",
-      status: concept["gl:status"] || "",
-      section: domains
-    };
-    const languages = localizedLanguages(localized, opts.languageOrder);
-    if (languages.length === 0) {
-      rows.push([shared.termid, shared.uri, shared.status, shared.section, "", "", "", "", "", "", "", ""].map(csvEscape).join(","));
-      continue;
-    }
-    for (const lang of languages) {
-      const lc = localized[lang] || {};
-      const designations = (lc["gl:designation"] || []).filter((d) => d["gl:term"]);
-      const preferred = designations.find((d) => d["gl:normativeStatus"] === "preferred") || designations[0];
-      const altTerms = designations.filter((d) => d !== preferred).map((d) => d["gl:term"]);
-      const localizedSources = lc["gl:source"]?.length ? lc["gl:source"] : managedSources;
-      rows.push([
-        shared.termid,
-        shared.uri,
-        shared.status,
-        shared.section,
-        lang,
-        preferred?.["gl:term"] || "",
-        altTerms.join("; "),
-        joinLines((lc["gl:definition"] || []).map((d) => d["gl:content"])),
-        joinLines((lc["gl:notes"] || []).map((d) => d["gl:content"])),
-        joinLines((lc["gl:examples"] || []).map((d) => d["gl:content"])),
-        localizedSources.map(sourceRefString).filter(Boolean).join("; "),
-        localizedSources.map(sourceLinkString).filter(Boolean).join("; ")
-      ].map(csvEscape).join(","));
-    }
-  }
-  return "\uFEFF" + rows.join("\r\n") + "\r\n";
-}
-function conceptJsonToTbx(concept) {
-  const id = concept["gl:identifier"] || "";
-  const uri = concept["@id"] || "";
-  const localized = concept["gl:localizedConcept"] || {};
-  const langSections = [];
-  for (const [lang, lc] of Object.entries(localized)) {
-    const descs = lc["gl:designation"] || [];
-    const definitions = (lc["gl:definition"] || []).filter((d) => d["gl:content"]);
-    const notes = (lc["gl:notes"] || []).filter((d) => d["gl:content"]);
-    const examples = (lc["gl:examples"] || []).filter((d) => d["gl:content"]);
-    const sources = lc["gl:source"] || [];
-    const entryStatus = lc["gl:entryStatus"] || "";
-    if (!descs.length && !definitions.length) continue;
-    const termEntries = [];
-    for (const d of descs) {
-      const term = d["gl:term"];
-      if (!term) continue;
-      const status = d["gl:normativeStatus"] || "";
-      const type = d["@type"] || "";
-      let gramGrp = "";
-      if (d["gl:grammarInfo"] && d["gl:grammarInfo"].length > 0) {
-        const gi = d["gl:grammarInfo"][0];
-        if (gi["gl:gender"]) gramGrp = `
-            <grammaticalGender>${escapeXml(gi["gl:gender"])}</grammaticalGender>`;
-        if (gi["gl:number"]) gramGrp += `
-            <grammaticalNumber>${escapeXml(gi["gl:number"])}</grammaticalNumber>`;
-        for (const pos of ["noun", "verb", "adj", "adverb", "preposition", "participle"]) {
-          if (gi[`gl:${pos}`]) gramGrp += `
-            <partOfSpeech>${pos}</partOfSpeech>`;
-        }
-      }
-      let posBlock = "";
-      if (type.includes("Abbreviation")) posBlock = "\n            <partOfSpeech>abbreviation</partOfSpeech>";
-      if (type.includes("Symbol")) posBlock = "\n            <partOfSpeech>symbol</partOfSpeech>";
-      termEntries.push(`          <termEntry>
-            <langSet xml:lang="${lang}">
-              <tig>
-                <term>${escapeXml(term)}</term>${gramGrp}${posBlock}
-              </tig>
-            </langSet>
-          </termEntry>`);
-    }
-    let defBlock = "";
-    if (definitions.length) {
-      const defParts = definitions.map((d) => `            <p>${escapeXml(d["gl:content"])}</p>`).join("\n");
-      defBlock = `
-          <descrip type="definition">
-${defParts}
-          </descrip>`;
-    }
-    let noteBlock = "";
-    for (let i = 0; i < notes.length; i++) {
-      noteBlock += `
-          <note type="note">${escapeXml(notes[i]["gl:content"])}</note>`;
-    }
-    for (let i = 0; i < examples.length; i++) {
-      noteBlock += `
-          <note type="example">${escapeXml(examples[i]["gl:content"])}</note>`;
-    }
-    let sourceBlock = "";
-    for (const src of sources) {
-      const origin = src["gl:origin"] || {};
-      const parts = [];
-      const ref = origin["gl:ref"];
-      if (ref) {
-        const refParts = [];
-        if (ref["gl:source"]) refParts.push(ref["gl:source"]);
-        if (ref["gl:id"]) refParts.push(ref["gl:id"]);
-        parts.push(refParts.join(" ") || "");
-      }
-      if (origin["gl:locality"]) {
-        const loc = origin["gl:locality"];
-        if (loc["gl:referenceFrom"]) parts.push(loc["gl:localityType"] ? `${loc["gl:localityType"]} ${loc["gl:referenceFrom"]}` : loc["gl:referenceFrom"]);
-      }
-      if (parts.filter(Boolean).length) {
-        sourceBlock += `
-          <ref>${escapeXml(parts.filter(Boolean).join(", "))}</ref>`;
-      }
-    }
-    let statusBlock = "";
-    if (entryStatus) {
-      statusBlock += `
-          <descrip type="entryStatus">${escapeXml(entryStatus)}</descrip>`;
-    }
-    const termEntriesBlock = termEntries.length ? "\n" + termEntries.join("\n") : "";
-    langSections.push({ lang, termEntries, blocks: [defBlock, noteBlock, sourceBlock, statusBlock].filter((b) => b).join("") });
-  }
-  if (!langSections.length) return "";
-  const bodyEntries = langSections.map((ls) => {
-    return `      <languageSection xml:lang="${ls.lang}">${ls.blocks}
-      </languageSection>`;
-  }).join("\n");
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<tbx style="dca" type="TBX-Basic" xml:lang="en" xmlns="urn:iso:std:iso:30042:ed-2">
-  <tbxHeader>
-    <fileDesc>
-      <source>${escapeXml(uri)}</source>
-    </fileDesc>
-  </tbxHeader>
-  <text>
-    <body>
-      <conceptEntry id="${escapeXml(id)}">
-${bodyEntries}
-      </conceptEntry>
-    </body>
-  </text>
-</tbx>
-`;
-}
-
 // scripts/generate-data.ts
 var __dirname3 = path3.dirname(new URL(import.meta.url).pathname);
 var ROOT = process.cwd();
@@ -1512,7 +1229,7 @@ async function processDataset(dir, register, opts) {
     for (const f of fs2.readdirSync(conceptsDir)) fs2.unlinkSync(path3.join(conceptsDir, f));
   }
   const concepts = [];
-  const jsonlds = [];
+  const conceptInstances = [];
   const langTermCounts = {};
   const langDefCounts = {};
   const availableFormats = ["ttl", "jsonld", "yaml", "tbx", "csv"];
@@ -1617,14 +1334,28 @@ async function processDataset(dir, register, opts) {
       const termid = String(conceptYaml.termid);
       const jsonld = yamlToJsonLd(conceptYaml, register, dsRefMaps);
       writeJson(path3.join(conceptsDir, `${termid}.json`), jsonld);
-      jsonlds.push(jsonld);
-      const ttlContent = conceptJsonToTurtle(jsonld);
-      fs2.writeFileSync(path3.join(conceptsDir, `${termid}.ttl`), ttlContent);
-      const skosJsonLd = conceptJsonToSkosJsonLd(jsonld);
-      fs2.writeFileSync(path3.join(conceptsDir, `${termid}.jsonld`), skosJsonLd);
-      const tbxContent = conceptJsonToTbx(jsonld);
-      if (tbxContent) {
-        fs2.writeFileSync(path3.join(conceptsDir, `${termid}.tbx`), tbxContent);
+      let conceptInstance = null;
+      try {
+        conceptInstance = parseConceptYaml(fs2.readFileSync(path3.join(dir, file), "utf8"), termid);
+      } catch (e) {
+        console.warn(`  ${termid}: canonical parse failed (${e.message}); skipping glossarist exports`);
+      }
+      if (conceptInstance) {
+        conceptInstances.push(conceptInstance);
+        fs2.writeFileSync(
+          path3.join(conceptsDir, `${termid}.ttl`),
+          conceptToTurtle(conceptInstance, { uriBase: refMaps.uriBase, registerId: register })
+        );
+        const conceptJsonLd = await emitOutputSet([conceptInstance], {
+          registerId: register,
+          uriBase: refMaps.uriBase,
+          formats: ["jsonld"]
+        });
+        fs2.writeFileSync(path3.join(conceptsDir, `${termid}.jsonld`), conceptJsonLd.jsonld);
+        const tbxContent = conceptsToTbx([conceptInstance], { registerId: register });
+        if (tbxContent) {
+          fs2.writeFileSync(path3.join(conceptsDir, `${termid}.tbx`), tbxContent);
+        }
       }
       fs2.copyFileSync(path3.join(dir, file), path3.join(conceptsDir, `${termid}.yaml`));
       concepts.push({
@@ -1640,8 +1371,13 @@ async function processDataset(dir, register, opts) {
       console.warn(`  Skipping ${file}: ${e.message}`);
     }
   }
-  fs2.writeFileSync(path3.join(DATA, register, `${register}.csv`), conceptsToCsv(jsonlds, { languageOrder: opts.languageOrder || opts.languages }));
-  fs2.writeFileSync(path3.join(DATA, register, `${register}.jsonld`), conceptsToSkosJsonLdGraph(jsonlds));
+  const aggregate = await emitOutputSet(conceptInstances, {
+    registerId: register,
+    uriBase: refMaps.uriBase,
+    languageOrder: opts.languageOrder || opts.languages
+  });
+  fs2.writeFileSync(path3.join(DATA, register, `${register}.csv`), aggregate.csv);
+  fs2.writeFileSync(path3.join(DATA, register, `${register}.jsonld`), aggregate.jsonld);
   const CHUNK_SIZE = 500;
   const chunks = [];
   for (let i = 0; i < concepts.length; i += CHUNK_SIZE) {
@@ -1684,7 +1420,7 @@ async function processDataset(dir, register, opts) {
   fs2.writeFileSync(
     path3.join(DATA, register, "graph-nodes.json"),
     JSON.stringify({
-      uriPrefix: `${refMaps.uriBase}/${register}/concept/`,
+      uriPrefix: buildConceptUriPrefix(refMaps.uriBase, register),
       registerId: register,
       nodes: graphNodeEntries
     })