@glossarist/concept-browser 0.7.133 → 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.133",
+  "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__/components/pipe-bundles.test.ts

@@ -167,3 +167,117 @@ describe('drawGenericPipes — pipe-and-thread contract', () => {
     expect(svg.querySelectorAll('line.pipe-seg').length).toBe(0);
   });
 });
+
+describe('drawGenericPipes — external + ellipsis ghosts (concept-model PR #91)', () => {
+  const pos = new Map<string, { x: number; y: number }>([
+    ['vim-2012/1.9', { x: 0, y: 0 }],
+    ['vim-2012/1.15', { x: 100, y: -50 }],
+  ]);
+
+  function makeGhostRelation(): GenericRelationWire {
+    return {
+      source: 'https://example.org/vim-2012/concept/1.9',
+      comprehensive: 'https://example.org/vim-2012/concept/1.9',
+      completeness: 'complete',
+      criterion: { eng: 'by system membership' },
+      register: 'vim-2012',
+      members: [
+        { uri: 'https://example.org/vim-2012/concept/1.15', presence: 'required', count: 'at_least_one',
+          delimitingCharacteristic: { eng: 'off-system measurement unit' } },
+        { uri: 'urn:gloss:ext:in-system measurement unit', presence: 'optional', count: 'any',
+          external: true, text: 'in-system measurement unit',
+          delimitingCharacteristic: { eng: 'in-system measurement unit' } },
+      ],
+    };
+  }
+
+  function makeEllipsisRelation(): GenericRelationWire {
+    return {
+      source: 'https://example.org/vim-2012/concept/1.9',
+      comprehensive: 'https://example.org/vim-2012/concept/1.9',
+      completeness: 'partial',
+      criterion: { eng: 'by epistemic status' },
+      register: 'vim-2012',
+      members: [
+        { uri: 'https://example.org/vim-2012/concept/1.15', presence: 'required', count: 'at_least_one',
+          delimitingCharacteristic: { eng: 'x' } },
+        { uri: 'urn:gloss:ellipsis', presence: 'required', count: 'exactly_one', ellipsis: true },
+      ],
+    };
+  }
+
+  it('renders an external member as a dashed pill with parenthesized text', () => {
+    const svg = makeSvg();
+    drawGenericPipes(svg, pos, {
+      isDark: false,
+      color: '#b45309',
+      isMuted: false,
+      relations: [makeGhostRelation()],
+      locale: 'eng',
+    });
+    const pill = svg.querySelector('rect.pipe-ghost-external');
+    expect(pill).toBeDefined();
+    expect(pill!.getAttribute('stroke-dasharray')).toBe('3 2');
+    const label = svg.querySelector('text.pipe-ghost-external-label');
+    expect(label).toBeDefined();
+    expect(label!.textContent).toBe('(in-system measurement unit)');
+  });
+
+  it('renders an ellipsis member as a muted ... ghost', () => {
+    const svg = makeSvg();
+    drawGenericPipes(svg, pos, {
+      isDark: false,
+      color: '#b45309',
+      isMuted: false,
+      relations: [makeEllipsisRelation()],
+      locale: 'eng',
+    });
+    const ell = svg.querySelector('text.pipe-ghost-ellipsis');
+    expect(ell).toBeDefined();
+    expect(ell!.textContent).toBe('...');
+  });
+
+  it('keeps a 1-resolved + 1-ghost rake alive (ghosts count as members)', () => {
+    const svg = makeSvg();
+    drawGenericPipes(svg, pos, {
+      isDark: false,
+      color: '#b45309',
+      isMuted: false,
+      relations: [makeGhostRelation()],
+      locale: 'eng',
+    });
+    /* 1 resolved member + 1 ghost = 2 layout members → 1 pipe + 2 threads. */
+    expect(svg.querySelectorAll('line.pipe-seg').length).toBe(3);
+  });
+
+  it('draws ghost threads dashed so they read as non-node placeholders', () => {
+    const svg = makeSvg();
+    drawGenericPipes(svg, pos, {
+      isDark: false,
+      color: '#b45309',
+      isMuted: false,
+      relations: [makeEllipsisRelation()],
+      locale: 'eng',
+    });
+    const dashed = Array.from(svg.querySelectorAll('line.pipe-seg'))
+      .filter(l => l.getAttribute('stroke-dasharray') === '3 3');
+    expect(dashed.length).toBe(1);
+  });
+
+  it('drops a rake whose members are ALL ghosts with no positioned anchor', () => {
+    const svg = makeSvg();
+    const emptyPos = new Map<string, { x: number; y: number }>([
+      ['vim-2012/1.9', { x: 0, y: 0 }],
+    ]);
+    drawGenericPipes(svg, emptyPos, {
+      isDark: false,
+      color: '#b45309',
+      isMuted: false,
+      relations: [makeGhostRelation()],
+      locale: 'eng',
+    });
+    /* 1.15 not in pos → zero positioned members → layout collapses onto
+       comp; ghosts have no anchor distinct from comp, so nothing draws. */
+    expect(svg.querySelectorAll('line.pipe-seg').length).toBe(0);
+  });
+});

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/__tests__/wire-keys.test.ts

@@ -60,6 +60,6 @@ describe('GL wire-key SSOT', () => {
     // The point of this test: when adding a key, you remember to update
     // the count; when removing, you notice the test fails. Catches
     // accidental drift in either direction.
-    expect(Object.keys(GL).length).toBe(91);
+    expect(Object.keys(GL).length).toBe(93);
   });
 });

package/src/adapters/jsonld-types.ts

@@ -43,6 +43,8 @@ export interface JsonLdRef {
   'gl:id'?: string;
   'gl:version'?: string;
   'gl:text'?: string;
+  'gl:external'?: boolean;
+  'gl:ellipsis'?: boolean;
   source?: string;
   id?: string;
   version?: string;

package/src/adapters/model-bridge.ts

@@ -298,7 +298,9 @@ function mapRefFromJsonLd(rawRef: JsonLdRef | string | undefined): Record<string
   refObj.id = rawRef[GL.LOCAL_ID] ?? rawRef.id;
   refObj.version = rawRef[GL.VERSION] ?? rawRef.version;
   if (rawRef[GL.TEXT]) refObj.text = rawRef[GL.TEXT];
-  return (refObj.source ?? refObj.id ?? refObj.version ?? refObj.text) != null
+  if (rawRef[GL.EXTERNAL] === true) refObj.external = true;
+  if (rawRef[GL.ELLIPSIS] === true) refObj.ellipsis = true;
+  return (refObj.source ?? refObj.id ?? refObj.version ?? refObj.text ?? refObj.external ?? refObj.ellipsis) != null
     ? refObj : null;
 }
 

package/src/adapters/types.ts

@@ -204,6 +204,14 @@ export interface GenericMemberWire {
    * distinguishes this specific concept from its coordinate concepts.
    * Required on every GenericMember. LocalizedString shape. */
   delimitingCharacteristic: Record<string, string>;
+  /** Inline external concept (concept-model PR #91). No dataset node —
+   * rendered as a dashed `(text)` ghost, never resolved to a URI. */
+  external?: boolean;
+  /** Author-acknowledged gap (concept-model PR #91). Rendered as a
+   * muted `...` ghost. */
+  ellipsis?: boolean;
+  /** Display text for external members (the parenthetical label). */
+  text?: string;
 }
 
 export interface GraphNode {

package/src/adapters/wire-keys.ts

@@ -108,6 +108,12 @@ export const GL = {
   VERSION: 'gl:version',
   TEXT: 'gl:text',
 
+  // ConceptRef external/ellipsis flags (concept-model PR #91).
+  // external = parenthetical (ISO 704:2022 §5.5.4.3.1); renders as `(text)`.
+  // ellipsis = author-acknowledged gap; renders as `...`.
+  EXTERNAL: 'gl:external',
+  ELLIPSIS: 'gl:ellipsis',
+
   // Locally-scoped id within source/origin/ref (NOT JSON-LD's @id)
   LOCAL_ID: 'gl:id',
 

package/src/components/relation-sphere/pipe-bundles.ts

@@ -80,7 +80,16 @@ export function drawGenericPipes(
     if (!compPos) continue;
 
     const memberPositions: PipeLayoutMember[] = [];
+    const ghostMembers: Array<{ member: GenericRelationWire['members'][number]; pos: NodePos }> = [];
     for (const m of rel.members) {
+      /* Ghost members (external / ellipsis, concept-model PR #91) carry
+         synthetic urn:gloss:* URIs that never resolve to a node — they
+         get virtual positions on an arc beyond the middle node and are
+         drawn as dashed ghosts after the layout. */
+      if (m.ellipsis === true || m.external === true) {
+        ghostMembers.push({ member: m, pos: { x: 0, y: 0 } });
+        continue;
+      }
       const parsed = UriRouter.parseUri(m.uri);
       if (!parsed) continue;
       const nid = `${parsed.registerId}/${parsed.conceptId}`;
@@ -89,7 +98,31 @@ export function drawGenericPipes(
       memberPositions.push({ pos: p, delimitingCharacteristic: m.delimitingCharacteristic });
     }
 
-    const layout = computePipeLayout(compPos, memberPositions);
+    /* Ghosts need a middle-node estimate to fan around. With ≥2
+       positioned members the layout gives it directly; with exactly 1
+       use the comp→member midpoint (computePipeLayout requires ≥2 and
+       would return null). Zero positioned members means the ghosts have
+       no anchor — drop the rake. */
+    if (memberPositions.length === 0 && ghostMembers.length > 0) continue;
+    let provisionalMiddle: NodePos | null = null;
+    if (memberPositions.length >= 2) {
+      const l = computePipeLayout(compPos, memberPositions);
+      provisionalMiddle = l ? l.middleNode : null;
+    } else if (memberPositions.length === 1) {
+      provisionalMiddle = {
+        x: (compPos.x + memberPositions[0].pos.x) / 2,
+        y: (compPos.y + memberPositions[0].pos.y) / 2,
+      };
+    }
+    if (!provisionalMiddle) continue;
+    assignGhostPositions(provisionalMiddle, compPos, memberPositions, ghostMembers);
+
+    const allPositions = [
+      ...memberPositions,
+      ...ghostMembers.map(g => ({ pos: g.pos, delimitingCharacteristic: g.member.delimitingCharacteristic })),
+    ];
+
+    const layout = computePipeLayout(compPos, allPositions);
     if (!layout) continue;
 
     /* 1. Thick parent pipe: comp → middle node. The characteristic
@@ -98,9 +131,25 @@ export function drawGenericPipes(
 
     /* 2. Thin threads: middle → each member. No per-thread labels —
           the characteristic is a single hyperedge-level field shared
-          by all members, rendered once on the pipe body. */
-    for (const thread of layout.threads) {
+          by all members, rendered once on the pipe body.
+          Ghost members are excluded here (step 2b draws their dashed
+          threads separately) — layout.threads preserves the
+          allPositions order: positioned members first, ghosts last. */
+    layout.threads.forEach((thread, i) => {
+      if (i >= memberPositions.length) return;
       drawSegment(svg, opts.color, thread.start, thread.end, THREAD_WIDTH);
+    });
+
+    /* 2b. Ghost members — external concepts and ellipsis gaps. Dashed
+          threads + dashed pills so they read as "present but not a
+          node of this dataset" (ISO 704:2022 §5.5.4.3.1). */
+    for (const ghost of ghostMembers) {
+      drawSegment(svg, opts.color, layout.middleNode, ghost.pos, THREAD_WIDTH, { dashed: true, opacity: 0.55 });
+      if (ghost.member.ellipsis === true) {
+        drawEllipsisGhost(svg, ghost.pos, opts.color);
+      } else {
+        drawExternalGhost(svg, ghost.pos, ghost.member.text ?? '', opts.color, opts.isDark);
+      }
     }
 
     /* 3. Square junction at the middle node (distinct from the rake's
@@ -129,7 +178,7 @@ export function drawGenericPipes(
   }
 }
 
-function drawSegment(svg: SVGSVGElement, color: string, from: NodePos, to: NodePos, width: number): void {
+function drawSegment(svg: SVGSVGElement, color: string, from: NodePos, to: NodePos, width: number, style?: { dashed?: boolean; opacity?: number }): void {
   const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
   line.setAttribute('class', 'pipe-seg');
   line.setAttribute('x1', String(from.x));
@@ -139,10 +188,93 @@ function drawSegment(svg: SVGSVGElement, color: string, from: NodePos, to: NodeP
   line.setAttribute('stroke', color);
   line.setAttribute('stroke-width', String(width));
   line.setAttribute('stroke-linecap', 'round');
-  line.setAttribute('opacity', '0.9');
+  line.setAttribute('opacity', String(style?.opacity ?? 0.9));
+  if (style?.dashed) line.setAttribute('stroke-dasharray', '3 3');
   svg.appendChild(line);
 }
 
+/**
+ * Place ghost members (external / ellipsis) on an arc beyond the middle
+ * node, on the side away from the comprehensive, fanned to match the
+ * spread of the positioned members. Pure 2D — ghosts never enter the
+ * 3D force layout.
+ */
+function assignGhostPositions(
+  middleNode: NodePos,
+  compPos: NodePos,
+  positioned: readonly { pos: NodePos }[],
+  ghosts: Array<{ pos: NodePos }>,
+): void {
+  if (ghosts.length === 0) return;
+  /* Fan radius: a bit beyond the average positioned-member distance
+     from the middle node so ghosts sit outside the resolved set. */
+  const avgDist = positioned.length > 0
+    ? positioned.reduce((s, m) => s + Math.hypot(m.pos.x - middleNode.x, m.pos.y - middleNode.y), 0) / positioned.length
+    : 40;
+  const radius = Math.max(avgDist, 40);
+  /* Base direction: away from the comprehensive. */
+  const awayX = middleNode.x - compPos.x;
+  const awayY = middleNode.y - compPos.y;
+  const awayLen = Math.hypot(awayX, awayY) || 1;
+  const baseAngle = Math.atan2(awayY / awayLen, awayX / awayLen);
+  const spread = 0.5; /* radians between consecutive ghosts */
+  ghosts.forEach((g, i) => {
+    const offset = ghosts.length === 1 ? 0 : (i - (ghosts.length - 1) / 2) * spread;
+    const a = baseAngle + offset;
+    g.pos.x = middleNode.x + Math.cos(a) * radius;
+    g.pos.y = middleNode.y + Math.sin(a) * radius;
+  });
+}
+
+/** Ellipsis ghost: a muted "..." — the author knew more members exist. */
+function drawEllipsisGhost(svg: SVGSVGElement, at: NodePos, color: string): void {
+  const text = document.createElementNS('http://www.w3.org/2000/svg', 'text');
+  text.setAttribute('class', 'pipe-ghost-ellipsis');
+  text.setAttribute('x', String(at.x));
+  text.setAttribute('y', String(at.y + 3));
+  text.setAttribute('text-anchor', 'middle');
+  text.setAttribute('fill', color);
+  text.setAttribute('font-size', '11');
+  text.setAttribute('font-family', 'JetBrains Mono, monospace');
+  text.setAttribute('font-weight', '600');
+  text.setAttribute('opacity', '0.8');
+  text.textContent = '...';
+  svg.appendChild(text);
+}
+
+/** External ghost: dashed-border pill with the parenthetical label. */
+function drawExternalGhost(svg: SVGSVGElement, at: NodePos, label: string, color: string, isDark: boolean): void {
+  const fontSize = 9;
+  const text = label ? `(${label})` : '(external)';
+  const w = Math.max(text.length * (fontSize * 0.55) + 10, 34);
+  const h = 15;
+  const rect = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
+  rect.setAttribute('class', 'pipe-ghost-external');
+  rect.setAttribute('x', String(at.x - w / 2));
+  rect.setAttribute('y', String(at.y - h / 2));
+  rect.setAttribute('width', String(w));
+  rect.setAttribute('height', String(h));
+  rect.setAttribute('rx', '4');
+  rect.setAttribute('fill', isDark ? 'rgba(26,18,8,0.85)' : 'rgba(255,255,255,0.92)');
+  rect.setAttribute('stroke', color);
+  rect.setAttribute('stroke-width', '1');
+  rect.setAttribute('stroke-dasharray', '3 2');
+  rect.setAttribute('opacity', '0.92');
+  svg.appendChild(rect);
+
+  const t = document.createElementNS('http://www.w3.org/2000/svg', 'text');
+  t.setAttribute('class', 'pipe-ghost-external-label');
+  t.setAttribute('x', String(at.x));
+  t.setAttribute('y', String(at.y + 3));
+  t.setAttribute('text-anchor', 'middle');
+  t.setAttribute('fill', color);
+  t.setAttribute('font-size', String(fontSize));
+  t.setAttribute('font-family', 'JetBrains Mono, monospace');
+  t.setAttribute('font-style', 'italic');
+  t.textContent = text;
+  svg.appendChild(t);
+}
+
 function drawSquare(svg: SVGSVGElement, cx: number, cy: number, half: number, fill: string, stroke: string): void {
   const rect = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
   rect.setAttribute('class', 'pipe-junction');

package/src/composables/use-concept-edges.ts

@@ -190,7 +190,26 @@ export function useConceptEdges(
     const isGeneric = rel instanceof GenericHyperedge;
     const members: any[] = (rel?.members ?? rel?.partitives ?? [])
       .map((m: any): any | null => {
-        const uri = resolveConceptRefUri(m?.ref);
+        const ref = m?.ref;
+        /* Ghost members (concept-model PR #91): external parenthetical
+           concepts and ellipsis gaps have no dataset node, so they get a
+           synthetic urn: URI plus flags. Renderers draw them as ghosts
+           without resolving the URI. */
+        if (ref?.ellipsis === true) {
+          return { uri: 'urn:gloss:ellipsis', presence: m?.presence, count: m?.count, ellipsis: true };
+        }
+        if (ref?.external === true || ref?.isExternal === true) {
+          const text = ref?.text ?? '';
+          return {
+            uri: `urn:gloss:ext:${text}`,
+            presence: m?.presence,
+            count: m?.count,
+            external: true,
+            text,
+            ...(isGeneric ? { delimitingCharacteristic: m?.delimitingCharacteristic } : {}),
+          };
+        }
+        const uri = resolveConceptRefUri(ref);
         if (!uri || uri === source) return null;
         const base: any = {
           uri,

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 ===