@glossarist/concept-browser 0.7.134 → 0.7.135

package/README.md

@@ -425,6 +425,26 @@ data:
 
 Or use a Glossarist GCR package — set `gcr_package` in your dataset config and the CLI downloads it automatically.
 
+## Bulk exports
+
+The build emits single-file aggregate distributions per dataset into `public/data/{id}/`:
+
+| File | Format | Contents |
+|------|--------|----------|
+| `{id}.csv` | CSV (UTF-8 BOM + CRLF, RFC 4180) | One row per concept × language — termid, uri, status, section, language, term, alt terms, definition, notes, examples, sources, source links. Opens directly in Excel. |
+| `{id}.jsonld` | SKOS JSON-LD | All concepts in one `@graph` document |
+| `{id}.ttl` | Turtle | dcat:Dataset + ConceptScheme metadata |
+
+Files from the dataset's GCR `compiled/` directory are also copied and listed. The dataset page's **Downloads** card offers everything found, unless you restrict it with `bulk_exports` in `site-config.yml`:
+
+```yaml
+bulk_exports:
+  - csv
+  - ttl
+```
+
+Values: `ttl`, `jsonld`, `csv`, `tbx`, `jsonl`, `yaml`. Absent or empty = offer all available.
+
 ## Deployment
 
 The build outputs a static site to `dist/`. Deploy it anywhere:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.134",
+  "version": "0.7.135",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {

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

@@ -26,6 +26,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",
@@ -838,15 +839,15 @@ function conceptJsonToTurtle(concept) {
   lines.push(" .");
   return lines.join("\n");
 }
-function conceptJsonToSkosJsonLd(concept) {
+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 = {
-    "@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
@@ -870,7 +871,101 @@ function conceptJsonToSkosJsonLd(concept) {
   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);
+  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"] || "";
@@ -1417,9 +1512,10 @@ async function processDataset(dir, register, opts) {
     for (const f of fs2.readdirSync(conceptsDir)) fs2.unlinkSync(path3.join(conceptsDir, f));
   }
   const concepts = [];
+  const jsonlds = [];
   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,6 +1617,7 @@ 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);
@@ -1543,6 +1640,8 @@ 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 CHUNK_SIZE = 500;
   const chunks = [];
   for (let i = 0; i < concepts.length; i += CHUNK_SIZE) {
@@ -1612,28 +1711,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 +1778,6 @@ async function processDataset(dir, register, opts) {
     year: opts.year ?? void 0,
     languageStats: langStats,
     availableFormats,
-    bulkFormats,
     hasBibliography: opts.hasBibliography,
     hasImages: opts.hasImages
   };
@@ -1685,8 +1787,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 +1840,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 +1874,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) ?? [];

package/scripts/generate-data.ts

@@ -47,6 +47,8 @@ import {
   conceptJsonToTurtle,
   conceptJsonToSkosJsonLd,
   conceptJsonToTbx,
+  conceptsToCsv,
+  conceptsToSkosJsonLdGraph,
 } from './lib/concept-formats';
 
 // MECE partitive multiplicity: 2 independent axes (ISO 704:2022).
@@ -689,9 +691,10 @@ async function processDataset(dir, register, opts) {
     for (const f of fs.readdirSync(conceptsDir)) fs.unlinkSync(path.join(conceptsDir, f));
   }
   const concepts = [];
+  const jsonlds = [];
   const langTermCounts = {};
   const langDefCounts = {};
-  const availableFormats = ['ttl', 'jsonld', 'yaml', 'tbx'];
+  const availableFormats = ['ttl', 'jsonld', 'yaml', 'tbx', 'csv'];
 
   // Pre-scan: build designation → concept ID lookup for same-dataset designation refs
   const designationLookup = new Map();
@@ -802,6 +805,7 @@ async function processDataset(dir, register, opts) {
       const termid = String(conceptYaml.termid);
       const jsonld = yamlToJsonLd(conceptYaml, register, dsRefMaps);
       writeJson(path.join(conceptsDir, `${termid}.json`), jsonld);
+      jsonlds.push(jsonld);
 
       const ttlContent = conceptJsonToTurtle(jsonld);
       fs.writeFileSync(path.join(conceptsDir, `${termid}.ttl`), ttlContent);
@@ -831,6 +835,10 @@ async function processDataset(dir, register, opts) {
     }
   }
 
+  // Aggregate distributions: single-file exports of the whole register
+  fs.writeFileSync(path.join(DATA, register, `${register}.csv`), conceptsToCsv(jsonlds, { languageOrder: opts.languageOrder || opts.languages }));
+  fs.writeFileSync(path.join(DATA, register, `${register}.jsonld`), conceptsToSkosJsonLdGraph(jsonlds));
+
   const CHUNK_SIZE = 500;
   const chunks = [];
   for (let i = 0; i < concepts.length; i += CHUNK_SIZE) {
@@ -908,29 +916,37 @@ async function processDataset(dir, register, opts) {
     };
   }
 
-  // Copy bulk format files from compiled/ directory (full GCR)
+  // Aggregate bulk exports offered on the dataset page: single-file
+  // distributions generated by this build plus any files shipped in the
+  // dataset's compiled/ directory. site-config `bulk_exports` restricts
+  // which formats are offered; absent/empty config offers all available.
+  const BULK_FORMAT_BY_EXT = {
+    '.ttl': 'turtle',
+    '.jsonld': 'jsonld',
+    '.xml': 'tbx',
+    '.jsonl': 'jsonl',
+    '.yaml': 'yaml',
+    '.csv': 'csv',
+  };
+  const bulkFormats = [];
+  const addBulkFormat = file => {
+    const dest = path.join(DATA, register, file);
+    if (!fs.existsSync(dest) || bulkFormats.some(f => f.file === file)) return;
+    const formatName = BULK_FORMAT_BY_EXT[path.extname(file)] || path.extname(file).slice(1);
+    bulkFormats.push({ file, format: formatName, size: fs.statSync(dest).size });
+  };
+  for (const file of [`${register}.csv`, `${register}.jsonld`]) addBulkFormat(file);
+
   const sourceRoot = path.dirname(dir);
   const compiledDir = path.join(sourceRoot, 'compiled');
-  const bulkFormats = [];
   if (fs.existsSync(compiledDir)) {
+    let copied = 0;
     for (const file of fs.readdirSync(compiledDir)) {
-      const src = path.join(compiledDir, file);
-      const dest = path.join(DATA, register, file);
-      fs.copyFileSync(src, dest);
-      const ext = path.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: fs.statSync(src).size });
-    }
-    if (bulkFormats.length) {
-      console.log(`  Copied ${bulkFormats.length} bulk format files`);
+      fs.copyFileSync(path.join(compiledDir, file), path.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())
@@ -977,7 +993,6 @@ async function processDataset(dir, register, opts) {
     year: opts.year ?? undefined,
     languageStats: langStats,
     availableFormats,
-    bulkFormats,
     hasBibliography: opts.hasBibliography,
     hasImages: opts.hasImages,
   };
@@ -987,10 +1002,16 @@ 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(path.join(DATA, register, 'manifest.json'), manifest);
 
   // Dataset-level RDF (WS J2/J5): dcat:Dataset + skos:ConceptScheme + skos:Collection per section.
+  // Runs before the manifest write so the ttl distribution is on disk when
+  // bulkFormats is assembled.
   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(path.join(DATA, register, 'manifest.json'), manifest);
 
   // Copy bibliography.yaml → bibliography.json
   // ALWAYS emit bibliography.json — empty stub `{ bibliography: [] }` when no
@@ -1058,6 +1079,11 @@ for (const ds of config.datasets) {
 
 const refMaps = buildRefMaps(config, registerCache);
 
+// site-config `bulk_exports`: which aggregate formats the dataset pages
+// offer for download. 'ttl' is accepted as an alias of the canonical
+// format id 'turtle'. Absent/empty → offer all available formats.
+const bulkExports = (config.bulkExports || []).map(f => (f === 'ttl' ? 'turtle' : f));
+
 for (let i = 0; i < config.datasets.length; i++) {
   const ds = config.datasets[i];
 
@@ -1110,6 +1136,7 @@ for (let i = 0; i < config.datasets.length; i++) {
     sections: reg?.sections ? reg.sections.map(s => s.toJSON()) : [],
     hasBibliography: fs.existsSync(path.join(datasetDir(ds), 'bibliography.yaml')),
     hasImages: fs.existsSync(path.join(datasetDir(ds), 'images')),
+    bulkExports,
   });
   const resolvedOwner = firstNonEmpty(reg?.owner, ds.owner) ?? '';
   const resolvedTags = firstNonEmpty(reg?.tags, ds.tags) ?? [];

package/scripts/lib/concept-formats.ts

@@ -1,5 +1,5 @@
 /**
- * Concept format emitters — Turtle, SKOS JSON-LD, TBX.
+ * Concept format emitters — Turtle, SKOS JSON-LD, TBX, aggregate CSV.
  *
  * Extracted from generate-data.ts. Each function takes a JSON-LD concept
  * object and serializes it to a different interchange format.
@@ -55,16 +55,17 @@ export function conceptJsonToTurtle(concept: Record<string, any>): string {
   return lines.join('\n');
 }
 
-export function conceptJsonToSkosJsonLd(concept: Record<string, any>): string {
+const 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: Record<string, any>): Record<string, any> {
   const uri = concept['@id'] || '';
   const id = concept['gl:identifier'] || '';
 
   const doc: Record<string, any> = {
-    '@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,
@@ -91,7 +92,126 @@ export function conceptJsonToSkosJsonLd(concept: Record<string, any>): string {
   if (Object.keys(definitions).length) doc['skos:definition'] = definitions;
   if (Object.keys(scopeNotes).length) doc['skos:scopeNote'] = scopeNotes;
 
-  return JSON.stringify(doc);
+  return doc;
+}
+
+export function conceptJsonToSkosJsonLd(concept: Record<string, any>): string {
+  return JSON.stringify({
+    '@context': SKOS_JSON_LD_CONTEXT,
+    ...buildSkosJsonLdObject(concept),
+  });
+}
+
+export function conceptsToSkosJsonLdGraph(concepts: Record<string, any>[]): string {
+  return JSON.stringify(
+    {
+      '@context': SKOS_JSON_LD_CONTEXT,
+      '@graph': concepts.map(buildSkosJsonLdObject),
+    },
+    null,
+    2,
+  );
+}
+
+export const CSV_COLUMNS = [
+  'termid',
+  'uri',
+  'status',
+  'section',
+  'language',
+  'term',
+  'alt_terms',
+  'definition',
+  'notes',
+  'examples',
+  'sources',
+  'source_links',
+] as const;
+
+function csvEscape(value: string): string {
+  if (/[",\r\n]/.test(value)) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+
+function joinLines(items: string[]): string {
+  return items.filter(Boolean).join('\n');
+}
+
+function localizedLanguages(localized: Record<string, any>, languageOrder?: string[]): string[] {
+  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: Record<string, any>): string {
+  const ref = src?.['gl:origin']?.['gl:ref'];
+  if (!ref) return '';
+  return [ref['gl:source'], ref['gl:id']].filter(Boolean).join(': ');
+}
+
+function sourceLinkString(src: Record<string, any>): string {
+  return src?.['gl:origin']?.['gl:link'] || '';
+}
+
+/**
+ * Aggregate CSV export: one row per (concept × language). Columns follow the
+ * Glossarist concept-model fields. UTF-8 BOM + CRLF so Excel opens the file
+ * with correct encoding without an import wizard.
+ */
+export function conceptsToCsv(
+  concepts: Record<string, any>[],
+  opts: { languageOrder?: string[] } = {},
+): string {
+  const rows: string[] = [CSV_COLUMNS.join(',')];
+
+  for (const concept of concepts) {
+    const localized = concept['gl:localizedConcept'] || {};
+    const domains = (concept['gl:domain'] || [])
+      .map((d: any) => 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: any) => d['gl:term']);
+      const preferred = designations.find((d: any) => d['gl:normativeStatus'] === 'preferred') || designations[0];
+      const altTerms = designations.filter((d: any) => d !== preferred).map((d: any) => 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: any) => d['gl:content'])),
+        joinLines((lc['gl:notes'] || []).map((d: any) => d['gl:content'])),
+        joinLines((lc['gl:examples'] || []).map((d: any) => 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';
 }
 
 export function conceptJsonToTbx(concept: Record<string, any>): string {

package/scripts/load-site-config.js

@@ -22,6 +22,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/load-site-config.ts

@@ -47,6 +47,7 @@ const 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/process-about-pages.js

@@ -28,6 +28,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/src/__tests__/scripts/concept-csv.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect } from 'vitest';
+import { conceptsToCsv, conceptsToSkosJsonLdGraph, CSV_COLUMNS } from '../../../scripts/lib/concept-formats';
+
+function parseCsv(csv: string): string[][] {
+  const body = csv.replace(/^\uFEFF/, '');
+  const rows: string[][] = [];
+  let row: string[] = [];
+  let field = '';
+  let quoted = false;
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (quoted) {
+      if (ch === '"') {
+        if (body[i + 1] === '"') { field += '"'; i++; }
+        else quoted = false;
+      } else {
+        field += ch;
+      }
+    } else if (ch === '"') {
+      quoted = true;
+    } else if (ch === ',') {
+      row.push(field); field = '';
+    } else if (ch === '\r' && body[i + 1] === '\n') {
+      row.push(field); rows.push(row); row = []; field = ''; i++;
+    } else {
+      field += ch;
+    }
+  }
+  return rows;
+}
+
+const baseConcept = {
+  '@id': 'https://example.com/vocab/concept/1-1-010',
+  'gl:identifier': '1-1-010',
+  'gl:status': 'valid',
+  'gl:domain': [{ 'gl:conceptId': 'section-1' }],
+  'gl:source': [{
+    'gl:sourceType': 'authoritative',
+    'gl:origin': { 'gl:ref': { 'gl:source': 'IALA Dictionary' }, 'gl:link': 'https://example.com/source' },
+  }],
+  'gl:localizedConcept': {
+    eng: {
+      'gl:designation': [
+        { 'gl:normativeStatus': 'preferred', 'gl:term': 'Buoyage and beaconage' },
+        { 'gl:normativeStatus': 'admitted', 'gl:term': 'Sea-marking (G.B.)' },
+      ],
+      'gl:definition': [{ 'gl:content': 'Ensemble of beacons, buoys, seamarks and small lights.' }],
+      'gl:notes': [{ 'gl:content': 'Note one.' }, { 'gl:content': 'Note two.' }],
+    },
+    fra: {
+      'gl:designation': [{ 'gl:normativeStatus': 'preferred', 'gl:term': 'Balisage' }],
+      'gl:definition': [{ 'gl:content': 'Ensemble de balises.' }],
+    },
+  },
+};
+
+describe('conceptsToCsv', () => {
+  it('emits UTF-8 BOM, CRLF line endings, and the model-driven header', () => {
+    const csv = conceptsToCsv([baseConcept]);
+    expect(csv.startsWith('\uFEFF')).toBe(true);
+    expect(csv.endsWith('\r\n')).toBe(true);
+    expect(csv).toContain('\r\n');
+    const rows = parseCsv(csv);
+    expect(rows[0]).toEqual([...CSV_COLUMNS]);
+  });
+
+  it('emits one row per concept and language', () => {
+    const rows = parseCsv(conceptsToCsv([baseConcept]));
+    expect(rows).toHaveLength(3);
+    expect(rows[1][CSV_COLUMNS.indexOf('termid')]).toBe('1-1-010');
+    expect(rows[1][CSV_COLUMNS.indexOf('language')]).toBe('eng');
+    expect(rows[2][CSV_COLUMNS.indexOf('language')]).toBe('fra');
+  });
+
+  it('honors languageOrder from the deployment config', () => {
+    const rows = parseCsv(conceptsToCsv([baseConcept], { languageOrder: ['fra', 'eng'] }));
+    expect(rows[1][CSV_COLUMNS.indexOf('language')]).toBe('fra');
+    expect(rows[2][CSV_COLUMNS.indexOf('language')]).toBe('eng');
+  });
+
+  it('keeps languages missing from languageOrder at the end', () => {
+    const rows = parseCsv(conceptsToCsv([baseConcept], { languageOrder: ['deu', 'eng'] }));
+    expect(rows.slice(1).map(r => r[CSV_COLUMNS.indexOf('language')])).toEqual(['eng', 'fra']);
+  });
+
+  it('separates the preferred term from alt terms', () => {
+    const rows = parseCsv(conceptsToCsv([baseConcept]));
+    const eng = rows[1];
+    expect(eng[CSV_COLUMNS.indexOf('term')]).toBe('Buoyage and beaconage');
+    expect(eng[CSV_COLUMNS.indexOf('alt_terms')]).toBe('Sea-marking (G.B.)');
+  });
+
+  it('joins multi-entry notes with a newline inside a quoted cell', () => {
+    const rows = parseCsv(conceptsToCsv([baseConcept]));
+    expect(rows[1][CSV_COLUMNS.indexOf('notes')]).toBe('Note one.\nNote two.');
+  });
+
+  it('escapes quotes and commas per RFC 4180', () => {
+    const concept = JSON.parse(JSON.stringify(baseConcept));
+    concept['gl:localizedConcept'].eng['gl:definition'] = [{ 'gl:content': 'Says "hello", loudly' }];
+    const csv = conceptsToCsv([concept]);
+    expect(csv).toContain('"Says ""hello"", loudly"');
+    expect(parseCsv(csv)[1][CSV_COLUMNS.indexOf('definition')]).toBe('Says "hello", loudly');
+  });
+
+  it('falls back to managed sources when the localization has none', () => {
+    const rows = parseCsv(conceptsToCsv([baseConcept]));
+    for (const row of rows.slice(1)) {
+      expect(row[CSV_COLUMNS.indexOf('sources')]).toBe('IALA Dictionary');
+      expect(row[CSV_COLUMNS.indexOf('source_links')]).toBe('https://example.com/source');
+    }
+  });
+
+  it('still emits a row for concepts with no localizations', () => {
+    const bare = {
+      '@id': 'https://example.com/vocab/concept/9-9-999',
+      'gl:identifier': '9-9-999',
+      'gl:status': 'retired',
+    };
+    const rows = parseCsv(conceptsToCsv([bare]));
+    expect(rows).toHaveLength(2);
+    expect(rows[1][CSV_COLUMNS.indexOf('termid')]).toBe('9-9-999');
+    expect(rows[1][CSV_COLUMNS.indexOf('language')]).toBe('');
+    expect(rows[1][CSV_COLUMNS.indexOf('term')]).toBe('');
+  });
+
+  it('carries section domains and status columns', () => {
+    const rows = parseCsv(conceptsToCsv([baseConcept]));
+    expect(rows[1][CSV_COLUMNS.indexOf('section')]).toBe('section-1');
+    expect(rows[1][CSV_COLUMNS.indexOf('status')]).toBe('valid');
+  });
+});
+
+describe('conceptsToSkosJsonLdGraph', () => {
+  it('wraps concepts in a shared @context and @graph', () => {
+    const parsed = JSON.parse(conceptsToSkosJsonLdGraph([baseConcept]));
+    expect(parsed['@context']['skos']).toBe('http://www.w3.org/2004/02/skos/core#');
+    expect(parsed['@graph']).toHaveLength(1);
+    expect(parsed['@graph'][0]['@id']).toBe(baseConcept['@id']);
+    expect(parsed['@graph'][0]['skos:prefLabel']['eng']).toBe('Buoyage and beaconage');
+  });
+});

package/src/composables/use-format-registry.ts

@@ -40,3 +40,4 @@ registerFormat({ id: 'jsonld', extension: 'jsonld',  mediaType: 'application/ld+
 registerFormat({ id: 'yaml',   extension: 'yaml',   mediaType: 'application/yaml',       label: 'YAML',        available: 'per-concept',  serialize: 'build' });
 registerFormat({ id: 'tbx',    extension: 'tbx.xml', mediaType: 'application/x-tbx',     label: 'TBX',         available: 'aggregate',    serialize: 'build' });
 registerFormat({ id: 'jsonl',  extension: 'jsonl',  mediaType: 'application/jsonl+json', label: 'JSON-Lines',  available: 'aggregate',    serialize: 'build' });
+registerFormat({ id: 'csv',    extension: 'csv',    mediaType: 'text/csv',              label: 'CSV',         available: 'aggregate',    serialize: 'build' });

package/src/config/types.ts

@@ -186,6 +186,7 @@ export const FORMAT_LABELS: Record<string, string> = {
   tbx: 'TBX-XML',
   jsonl: 'JSONL',
   yaml: 'YAML',
+  csv: 'CSV (Excel)',
 };
 
 // === Pages ===