@glossarist/concept-browser 0.7.134 → 0.7.136

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/fetch-datasets.js

@@ -30,6 +30,7 @@ var SNAKE_TO_CAMEL = {
   footer_nav: "footerNav",
   footer_logo: "footerLogo",
   news_dir: "newsDir",
+  bulk_exports: "bulkExports",
   // Dataset-level
   gcr_package: "gcrPackage",
   source_repo: "sourceRepo",

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";
@@ -26,6 +35,7 @@ var SNAKE_TO_CAMEL = {
   footer_nav: "footerNav",
   footer_logo: "footerLogo",
   news_dir: "newsDir",
+  bulk_exports: "bulkExports",
   // Dataset-level
   gcr_package: "gcrPackage",
   source_repo: "sourceRepo",
@@ -545,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";
@@ -781,207 +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");
-}
-function conceptJsonToSkosJsonLd(concept) {
-  const uri = concept["@id"] || "";
-  const id = concept["gl:identifier"] || "";
-  const doc = {
-    "@context": {
-      skos: "http://www.w3.org/2004/02/skos/core#",
-      dcterms: "http://purl.org/dc/terms/",
-      "@language": { "@container": "@language" }
-    },
-    "@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 JSON.stringify(doc);
-}
-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();
@@ -1417,9 +1229,10 @@ async function processDataset(dir, register, opts) {
     for (const f of fs2.readdirSync(conceptsDir)) fs2.unlinkSync(path3.join(conceptsDir, f));
   }
   const concepts = [];
+  const conceptInstances = [];
   const langTermCounts = {};
   const langDefCounts = {};
-  const availableFormats = ["ttl", "jsonld", "yaml", "tbx"];
+  const availableFormats = ["ttl", "jsonld", "yaml", "tbx", "csv"];
   const designationLookup = /* @__PURE__ */ new Map();
   for (const file of files) {
     try {
@@ -1521,13 +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);
-      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({
@@ -1543,6 +1371,13 @@ async function processDataset(dir, register, opts) {
       console.warn(`  Skipping ${file}: ${e.message}`);
     }
   }
+  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) {
@@ -1585,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
     })
@@ -1612,28 +1447,32 @@ async function processDataset(dir, register, opts) {
       definitions: langDefCounts[lang] || 0
     };
   }
+  const BULK_FORMAT_BY_EXT = {
+    ".ttl": "turtle",
+    ".jsonld": "jsonld",
+    ".xml": "tbx",
+    ".jsonl": "jsonl",
+    ".yaml": "yaml",
+    ".csv": "csv"
+  };
+  const bulkFormats = [];
+  const addBulkFormat = (file) => {
+    const dest = path3.join(DATA, register, file);
+    if (!fs2.existsSync(dest) || bulkFormats.some((f) => f.file === file)) return;
+    const formatName = BULK_FORMAT_BY_EXT[path3.extname(file)] || path3.extname(file).slice(1);
+    bulkFormats.push({ file, format: formatName, size: fs2.statSync(dest).size });
+  };
+  for (const file of [`${register}.csv`, `${register}.jsonld`]) addBulkFormat(file);
   const sourceRoot = path3.dirname(dir);
   const compiledDir = path3.join(sourceRoot, "compiled");
-  const bulkFormats = [];
   if (fs2.existsSync(compiledDir)) {
+    let copied = 0;
     for (const file of fs2.readdirSync(compiledDir)) {
-      const src = path3.join(compiledDir, file);
-      const dest = path3.join(DATA, register, file);
-      fs2.copyFileSync(src, dest);
-      const ext = path3.extname(file);
-      const formatMap = {
-        ".ttl": "turtle",
-        ".jsonld": "jsonld",
-        ".xml": "tbx",
-        ".jsonl": "jsonl",
-        ".yaml": "yaml"
-      };
-      const formatName = formatMap[ext] || ext.slice(1);
-      bulkFormats.push({ file, format: formatName, size: fs2.statSync(src).size });
-    }
-    if (bulkFormats.length) {
-      console.log(`  Copied ${bulkFormats.length} bulk format files`);
+      fs2.copyFileSync(path3.join(compiledDir, file), path3.join(DATA, register, file));
+      addBulkFormat(file);
+      copied += 1;
     }
+    if (copied) console.log(`  Copied ${copied} bulk format files from compiled/`);
   }
   const sourceStats = Array.from(stats.sourceMap.values()).map((s) => ({
     ref: s.ref,
@@ -1675,7 +1514,6 @@ async function processDataset(dir, register, opts) {
     year: opts.year ?? void 0,
     languageStats: langStats,
     availableFormats,
-    bulkFormats,
     hasBibliography: opts.hasBibliography,
     hasImages: opts.hasImages
   };
@@ -1685,8 +1523,10 @@ async function processDataset(dir, register, opts) {
   if (opts.status) manifest.editionStatus = opts.status;
   if (opts.ordering) manifest.ordering = opts.ordering;
   if (opts.sections && opts.sections.length > 0) manifest.sections = opts.sections;
-  writeJson(path3.join(DATA, register, "manifest.json"), manifest);
   await writeDatasetRdf(register, manifest, concepts, refMaps, opts);
+  addBulkFormat(`${register}.ttl`);
+  manifest.bulkFormats = opts.bulkExports?.length ? bulkFormats.filter((f) => opts.bulkExports.includes(f.format)) : bulkFormats;
+  writeJson(path3.join(DATA, register, "manifest.json"), manifest);
   const bibPath = path3.join(sourceRoot, "bibliography.yaml");
   if (fs2.existsSync(bibPath)) {
     const rawBib = readYaml(bibPath);
@@ -1736,6 +1576,7 @@ for (const ds of config.datasets) {
   }
 }
 var refMaps = buildRefMaps(config, registerCache);
+var bulkExports = (config.bulkExports || []).map((f) => f === "ttl" ? "turtle" : f);
 for (let i = 0; i < config.datasets.length; i++) {
   const ds = config.datasets[i];
   const dir = path3.join(datasetDir(ds), "concepts");
@@ -1769,7 +1610,8 @@ for (let i = 0; i < config.datasets.length; i++) {
     ordering: reg?.ordering || null,
     sections: reg?.sections ? reg.sections.map((s) => s.toJSON()) : [],
     hasBibliography: fs2.existsSync(path3.join(datasetDir(ds), "bibliography.yaml")),
-    hasImages: fs2.existsSync(path3.join(datasetDir(ds), "images"))
+    hasImages: fs2.existsSync(path3.join(datasetDir(ds), "images")),
+    bulkExports
   });
   const resolvedOwner = firstNonEmpty(reg?.owner, ds.owner) ?? "";
   const resolvedTags = firstNonEmpty(reg?.tags, ds.tags) ?? [];