@glossarist/concept-browser 0.3.4 → 0.4.0

package/README.md

@@ -57,9 +57,10 @@ datasets.yml
               └─> public/data/{id}/
                   ├── manifest.json      Dataset metadata
                   ├── index.json         Concept listing (chunked for large sets)
-                  ├── edges.json         Pre-computed cross-references
+                  ├── edges.json         Pre-computed cross-reference + domain edges
+                  ├── domain-nodes.json  Domain classification nodes
                   └── concepts/*.json    Individual concept documents
-                  └─> scripts/build-edges.js  (extract graph edges)
+          └─> scripts/build-edges.js  (extract graph + domain edges)
 ```
 
 ### Step-by-step

package/cli/index.mjs

@@ -100,7 +100,8 @@ Environment:
     // Run vite build using the package's vite.config.ts
     console.log(`\n=== BUILD SPA ===\n`);
     const viteConfig = resolve(pkgRoot, 'vite.config.ts');
-    execSync(`npx vite build --config ${viteConfig}`, {
+    const viteBin = resolve(pkgRoot, 'node_modules', '.bin', 'vite');
+    execSync(`${viteBin} build --config ${viteConfig}`, {
       stdio: 'inherit',
       env: { ...process.env },
     });

package/env.d.ts

@@ -1,5 +1,10 @@
 /// <reference types="vite/client" />
 
+declare module '*.json' {
+  const value: any;
+  export default value;
+}
+
 declare module '*.vue' {
   import type { DefineComponent } from 'vue'
   const component: DefineComponent<{}, {}, any>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -13,7 +13,8 @@
     "preview": "vite preview",
     "fetch-datasets": "node scripts/fetch-datasets.mjs",
     "generate-data": "node scripts/generate-data.mjs",
-    "build:full": "npm run fetch-datasets && npm run generate-data && node scripts/build-edges.js && npm run build",
+    "generate-ontology": "node scripts/generate-ontology-data.mjs && node scripts/generate-ontology-schema.mjs",
+    "build:full": "npm run generate-ontology && npm run fetch-datasets && npm run generate-data && node scripts/build-edges.js && npm run build",
     "build:site": "concept-browser --site build",
     "test": "vitest run",
     "test:watch": "vitest"
@@ -23,7 +24,7 @@
     "@vitejs/plugin-vue": "^5.2.3",
     "autoprefixer": "^10.4.21",
     "d3": "^7.9.0",
-    "glossarist": "^0.2.0",
+    "glossarist": "^0.3.0",
     "js-yaml": "^4.1.0",
     "pinia": "^2.3.1",
     "postcss": "^8.5.3",

package/scripts/build-edges.js

@@ -1,7 +1,7 @@
 /**
- * Pre-computes cross-reference edges for each dataset.
- * Reads all concept JSON files, extracts structured and inline references,
- * and writes edges.json for each dataset.
+ * Pre-computes cross-reference and domain edges for each dataset.
+ * Reads all concept JSON files, extracts structured references and
+ * authoritative sources (domains), and writes edges.json + domain-nodes.json.
  *
  * Usage: node scripts/build-edges.js
  */
@@ -13,12 +13,18 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = process.cwd();
 const DATA_DIR = join(ROOT, 'public', 'data');
 
-function extractEdgesFromConcept(concept, registerId) {
+// --- Normalization ---
+
+function slugify(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, '').replace(/[\s/]+/g, '-');
+}
+
+// --- Extractors (open/closed: add new extractors to EXTRACTORS array) ---
+
+function extractReferences(concept, registerId) {
   const edges = [];
   const sourceUri = concept['@id'];
-
-  for (const [_lang, lc] of Object.entries(concept['gl:localizedConcept'] || {})) {
-    // Structured cross-references (gl:references array, pre-computed during data generation)
+  for (const [lang, lc] of Object.entries(concept['gl:localizedConcept'] || {})) {
     if (lc['gl:references']) {
       for (const ref of lc['gl:references']) {
         if (ref['@id'] && ref['@id'] !== sourceUri) {
@@ -28,15 +34,45 @@ function extractEdgesFromConcept(concept, registerId) {
             type: 'references',
             label: ref['gl:term'] || undefined,
             register: registerId,
+            lang,
           });
         }
       }
     }
   }
+  return edges;
+}
 
+function extractDomains(concept, registerId) {
+  const edges = [];
+  const sourceUri = concept['@id'];
+  const lcs = concept['gl:localizedConcept'] || {};
+  const langs = Object.keys(lcs);
+  const seen = new Set();
+  for (const lang of langs) {
+    const domain = lcs[lang]['gl:domain'];
+    if (domain && !seen.has(domain)) {
+      seen.add(domain);
+      edges.push({
+        source: sourceUri,
+        target: `https://glossarist.org/${registerId}/domain/${slugify(domain)}`,
+        type: 'domain',
+        label: domain,
+        register: registerId,
+      });
+    }
+  }
   return edges;
 }
 
+const EXTRACTORS = [extractReferences, extractDomains];
+
+function extractAllEdges(concept, registerId) {
+  return EXTRACTORS.flatMap(fn => fn(concept, registerId));
+}
+
+// --- Build ---
+
 function buildEdgesForDataset(datasetDir, registerId) {
   const conceptsDir = join(datasetDir, 'concepts');
   if (!existsSync(conceptsDir)) {
@@ -48,13 +84,20 @@ function buildEdgesForDataset(datasetDir, registerId) {
   console.log(`  Processing ${files.length} concepts...`);
 
   const allEdges = [];
+  const domainConceptCount = new Map();
   let processed = 0;
 
   for (const file of files) {
     try {
       const data = JSON.parse(readFileSync(join(conceptsDir, file), 'utf-8'));
-      const edges = extractEdgesFromConcept(data, registerId);
+      const edges = extractAllEdges(data, registerId);
       allEdges.push(...edges);
+
+      for (const edge of edges) {
+        if (edge.type === 'domain') {
+          domainConceptCount.set(edge.target, (domainConceptCount.get(edge.target) || 0) + 1);
+        }
+      }
     } catch (e) {
       console.error(`  Error processing ${file}: ${e.message}`);
     }
@@ -64,11 +107,11 @@ function buildEdgesForDataset(datasetDir, registerId) {
     }
   }
 
-  // Deduplicate edges by source+target pair
+  // Deduplicate edges by source+target+type+lang
   const seen = new Set();
   const deduped = [];
   for (const edge of allEdges) {
-    const key = `${edge.source}→${edge.target}`;
+    const key = `${edge.source}→${edge.target}→${edge.type}→${edge.lang || ''}`;
     if (!seen.has(key)) {
       seen.add(key);
       deduped.push(edge);
@@ -84,6 +127,31 @@ function buildEdgesForDataset(datasetDir, registerId) {
   const outputPath = join(datasetDir, 'edges.json');
   writeFileSync(outputPath, JSON.stringify(output, null, 2));
   console.log(`  Written ${deduped.length} edges to edges.json (${(JSON.stringify(output).length / 1024).toFixed(1)} KB)`);
+
+  // Build domain-nodes.json
+  const domainEdgeMap = new Map();
+  for (const edge of deduped) {
+    if (edge.type === 'domain') {
+      const existing = domainEdgeMap.get(edge.target);
+      if (existing) {
+        existing.labels.add(edge.label);
+      } else {
+        domainEdgeMap.set(edge.target, { uri: edge.target, labels: new Set([edge.label]), registerId });
+      }
+    }
+  }
+
+  const domainNodes = [...domainEdgeMap.values()].map(d => ({
+    uri: d.uri,
+    label: [...d.labels][0],
+    registerId: d.registerId,
+    conceptCount: domainConceptCount.get(d.uri) || 0,
+  })).sort((a, b) => b.conceptCount - a.conceptCount);
+
+  const domainOutput = { registerId, domainNodes };
+  const domainPath = join(datasetDir, 'domain-nodes.json');
+  writeFileSync(domainPath, JSON.stringify(domainOutput, null, 2));
+  console.log(`  Written ${domainNodes.length} domain nodes to domain-nodes.json`);
 }
 
 // Main

package/scripts/generate-data.mjs

@@ -30,6 +30,16 @@ function loadConceptFile(filePath) {
   if (docs.length >= 1 && docs[0].data && docs[0].data.identifier !== undefined) {
     const mc = docs[0];
     const result = { termid: String(mc.data.identifier) };
+
+    // Managed concept-level fields
+    if (mc.related) result._related = mc.related;
+    if (mc.data.domains) result._domains = mc.data.domains;
+    if (mc.dates) result._dates = mc.dates;
+    if (mc.sources) result._sources = mc.sources;
+    if (mc.status) result._status = mc.status;
+    if (mc.schema_version) result._schemaVersion = mc.schema_version;
+    if (mc.date_accepted) result._dateAccepted = mc.date_accepted;
+
     for (const doc of docs.slice(1)) {
       if (!doc || !doc.data || !doc.data.language_code) continue;
       const lang = doc.data.language_code;
@@ -49,17 +59,46 @@ function writeJson(filePath, data) {
 }
 
 function termToDesignation(term) {
+  const typeMap = {
+    expression: 'gl:Expression',
+    abbreviation: 'gl:Abbreviation',
+    symbol: 'gl:Symbol',
+    letter_symbol: 'gl:LetterSymbol',
+    'graphical symbol': 'gl:GraphicalSymbol',
+  };
   const doc = {
-    '@type': term.type === 'expression' ? 'gl:Expression'
-      : term.type === 'symbol' ? 'gl:Symbol'
-      : term.type === 'abbreviation' ? 'gl:Abbreviation'
-      : 'gl:Designation',
+    '@type': typeMap[term.type] || 'gl:Designation',
     'gl:normativeStatus': term.normative_status || 'preferred',
     'gl:term': term.designation,
   };
-  if (term.gender) doc['gl:gender'] = term.gender;
-  if (term.plurality) doc['gl:plurality'] = term.plurality;
+
+  if (term.grammar_info && term.grammar_info.length > 0) {
+    doc['gl:grammarInfo'] = term.grammar_info.map(gi => {
+      const g = {};
+      if (gi.gender) g['gl:gender'] = gi.gender;
+      if (gi.number) g['gl:number'] = gi.number;
+      for (const pos of ['noun', 'verb', 'adj', 'adverb', 'preposition', 'participle']) {
+        if (gi[pos]) g[`gl:${pos}`] = gi[pos];
+      }
+      return g;
+    });
+  }
+
   if (term.international !== undefined) doc['gl:international'] = term.international;
+  if (term.absent !== undefined) doc['gl:absent'] = term.absent;
+  if (term.geographical_area) doc['gl:geographicalArea'] = term.geographical_area;
+  if (term.term_type) doc['gl:termType'] = term.term_type;
+  if (term.prefix) doc['gl:prefix'] = term.prefix;
+  if (term.usage_info) doc['gl:usageInfo'] = term.usage_info;
+  if (term.field_of_application) doc['gl:fieldOfApplication'] = term.field_of_application;
+
+  if (term.acronym !== undefined) doc['gl:acronym'] = term.acronym;
+  if (term.initialism !== undefined) doc['gl:initialism'] = term.initialism;
+  if (term.truncation !== undefined) doc['gl:truncation'] = term.truncation;
+
+  if (term.text) doc['gl:text'] = term.text;
+  if (term.image) doc['gl:image'] = term.image;
+
   return doc;
 }
 
@@ -81,8 +120,24 @@ function sourcesToJsonLd(sources) {
     if (s.status) doc['gl:sourceStatus'] = s.status;
     if (s.origin) {
       const origin = { '@type': 'gl:Citation' };
-      if (s.origin.ref) origin['gl:ref'] = s.origin.ref;
-      if (s.origin.clause) origin['gl:clause'] = s.origin.clause;
+      if (s.origin.ref) {
+        const ref = s.origin.ref;
+        const refObj = { '@type': 'gl:Ref' };
+        if (ref.source) refObj['gl:source'] = ref.source;
+        if (ref.id) refObj['gl:id'] = ref.id;
+        if (ref.version) refObj['gl:version'] = ref.version;
+        origin['gl:ref'] = refObj;
+      }
+      if (s.origin.locality) {
+        const loc = s.origin.locality;
+        const locObj = {};
+        if (loc.type) locObj['gl:localityType'] = loc.type;
+        if (loc.reference_from) locObj['gl:referenceFrom'] = loc.reference_from;
+        if (loc.referenceFrom) locObj['gl:referenceFrom'] = loc.referenceFrom;
+        if (loc.reference_to) locObj['gl:referenceTo'] = loc.reference_to;
+        if (loc.referenceTo) locObj['gl:referenceTo'] = loc.referenceTo;
+        origin['gl:locality'] = locObj;
+      }
       if (s.origin.link) origin['gl:link'] = s.origin.link;
       doc['gl:origin'] = origin;
     }
@@ -143,7 +198,7 @@ function buildRefMaps(config) {
   if (xref.urnStandardMap) Object.assign(urnStandardMap, xref.urnStandardMap);
 
   const uriBase = config.uriBase || `https://${config.domain}`;
-  return { refPrefixMap, urnStandardMap, uriBase };
+  return { refPrefixMap, urnStandardMap, uriBase, register: null };
 }
 
 function extractInlineRefs(localizedData, refMaps) {
@@ -178,6 +233,18 @@ function extractInlineRefs(localizedData, refMaps) {
     if (datasetId) refs.push({ id: `${uriBase}/${datasetId}/concept/${m[2]}`, term: (m[4] || m[3]).trim() });
   }
 
+  // Generic {{term, concept_id}} — same-dataset cross-reference (e.g. VIML)
+  const register = refMaps.register;
+  for (const m of fullText.matchAll(/\{\{([^,}]+),\s*([A-Za-z0-9.]+)\}\}/g)) {
+    const termName = m[1].trim();
+    const conceptId = m[2].trim();
+    // Skip if already matched by IEV or URN patterns
+    if (refPrefixMap && refPrefixMap[termName]) continue;
+    if (/^\d/.test(conceptId) || /^[A-Z]\.\d/.test(conceptId)) {
+      refs.push({ id: `${uriBase}/${register}/concept/${conceptId}`, term: termName });
+    }
+  }
+
   const seen = new Set();
   return refs.filter(r => {
     if (seen.has(r.id)) return false;
@@ -210,6 +277,10 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
     };
 
     if (lc.entry_status) lDoc['gl:entryStatus'] = lc.entry_status;
+    if (lc.classification) lDoc['gl:classification'] = lc.classification;
+    if (lc.review_type) lDoc['gl:reviewType'] = lc.review_type;
+    if (lc.script) lDoc['gl:script'] = lc.script;
+    if (lc.system) lDoc['gl:system'] = lc.system;
     if (lc.terms && lc.terms.length > 0) lDoc['gl:designation'] = lc.terms.map(termToDesignation);
     if (lc.definition) lDoc['gl:definition'] = defsToJsonLd(lc.definition);
     if (lc.notes && lc.notes.length > 0) lDoc['gl:notes'] = defsToJsonLd(lc.notes);
@@ -223,6 +294,7 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
     if (lc.review_status) lDoc['gl:reviewStatus'] = lc.review_status;
     if (lc.review_decision) lDoc['gl:reviewDecision'] = lc.review_decision;
     if (lc.review_decision_notes) lDoc['gl:reviewDecisionNotes'] = lc.review_decision_notes;
+    if (lc.domain) lDoc['gl:domain'] = lc.domain;
     if (lc.dates && lc.dates.length > 0) {
       lDoc['gl:dates'] = lc.dates.map(d => ({
         'gl:dateType': d.type,
@@ -245,6 +317,48 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
     doc['gl:localizedConcept'] = localizations;
   }
 
+  // Managed concept-level fields (v3)
+  if (conceptYaml._status) doc['gl:status'] = conceptYaml._status;
+  if (conceptYaml._schemaVersion) doc['gl:schemaVersion'] = conceptYaml._schemaVersion;
+  if (conceptYaml._dateAccepted) doc['gl:dateAccepted'] = conceptYaml._dateAccepted;
+
+  if (conceptYaml._dates && conceptYaml._dates.length > 0) {
+    doc['gl:dates'] = conceptYaml._dates.map(d => ({
+      'gl:dateType': d.type,
+      'gl:date': d.date,
+    }));
+  }
+
+  if (conceptYaml._sources && conceptYaml._sources.length > 0) {
+    doc['gl:source'] = sourcesToJsonLd(conceptYaml._sources);
+  }
+
+  if (conceptYaml._domains && conceptYaml._domains.length > 0) {
+    doc['gl:domain'] = conceptYaml._domains.map(d => {
+      const domain = { '@type': 'gl:ConceptReference' };
+      if (d.concept_id) domain['gl:conceptId'] = d.concept_id;
+      if (d.source) domain['gl:source'] = d.source;
+      if (d.urn) domain['gl:urn'] = d.urn;
+      if (d.ref_type) domain['gl:refType'] = d.ref_type;
+      return domain;
+    });
+  }
+
+  if (conceptYaml._related && conceptYaml._related.length > 0) {
+    doc['gl:related'] = conceptYaml._related.map(r => {
+      const rel = { '@type': 'gl:RelatedConcept' };
+      if (r.type) rel['gl:relationshipType'] = r.type;
+      if (r.content) rel['gl:content'] = r.content;
+      if (r.ref) {
+        const ref = {};
+        if (r.ref.source) ref['gl:source'] = r.ref.source;
+        if (r.ref.id) ref['gl:id'] = r.ref.id;
+        rel['gl:ref'] = ref;
+      }
+      return rel;
+    });
+  }
+
   return doc;
 }
 
@@ -352,7 +466,8 @@ function conceptJsonToSkosJsonLd(concept) {
 }
 
 function escapeXml(s) {
-  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+  const str = Array.isArray(s) ? s.join(', ') : String(s ?? '');
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 }
 
 function conceptJsonToTbx(concept) {
@@ -378,15 +493,22 @@ function conceptJsonToTbx(concept) {
       const status = d['gl:normativeStatus'] || '';
       const type = d['@type'] || '';
       let gramGrp = '';
-      if (d['gl:gender']) gramGrp = `\n            <grammaticalGender>${escapeXml(d['gl:gender'])}</grammaticalGender>`;
-      let partOfSpeech = '';
-      if (type.includes('Abbreviation')) partOfSpeech = '\n            <partOfSpeech>abbreviation</partOfSpeech>';
-      if (type.includes('Symbol')) partOfSpeech = '\n            <partOfSpeech>symbol</partOfSpeech>';
+      if (d['gl:grammarInfo'] && d['gl:grammarInfo'].length > 0) {
+        const gi = d['gl:grammarInfo'][0];
+        if (gi['gl:gender']) gramGrp = `\n            <grammaticalGender>${escapeXml(gi['gl:gender'])}</grammaticalGender>`;
+        if (gi['gl:number']) gramGrp += `\n            <grammaticalNumber>${escapeXml(gi['gl:number'])}</grammaticalNumber>`;
+        for (const pos of ['noun', 'verb', 'adj', 'adverb', 'preposition', 'participle']) {
+          if (gi[`gl:${pos}`]) gramGrp += `\n            <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}${partOfSpeech}
+                <term>${escapeXml(term)}</term>${gramGrp}${posBlock}
               </tig>
             </langSet>
           </termEntry>`);
@@ -410,10 +532,19 @@ function conceptJsonToTbx(concept) {
     for (const src of sources) {
       const origin = src['gl:origin'] || {};
       const parts = [];
-      if (origin['gl:ref']) parts.push(origin['gl:ref']);
-      if (origin['gl:clause']) parts.push(origin['gl:clause']);
-      if (parts.length) {
-        sourceBlock += `\n          <ref>${escapeXml(parts.join(', '))}</ref>`;
+      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 += `\n          <ref>${escapeXml(parts.filter(Boolean).join(', '))}</ref>`;
       }
     }
 
@@ -460,6 +591,7 @@ function processDataset(dir, register, opts) {
   const langTermCounts = {};
   const langDefCounts = {};
   const availableFormats = ['ttl', 'jsonld', 'yaml', 'tbx'];
+  const dsRefMaps = { ...refMaps, register };
 
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
@@ -468,7 +600,7 @@ function processDataset(dir, register, opts) {
       if (!conceptYaml || !conceptYaml.termid) continue;
 
       const termid = String(conceptYaml.termid);
-      const jsonld = yamlToJsonLd(conceptYaml, register, refMaps);
+      const jsonld = yamlToJsonLd(conceptYaml, register, dsRefMaps);
       writeJson(path.join(conceptsDir, `${termid}.json`), jsonld);
 
       // Generate Turtle format

package/scripts/generate-ontology-data.mjs

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+/**
+ * Extract SKOS taxonomy data from concept-model TTL files into JSON
+ * for browser consumption via the OntologyRegistry.
+ *
+ * Reads from:  ../concept-model/ontologies/taxonomies/*.ttl
+ * Writes to:   src/data/taxonomies.json
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..');
+const TAXONOMY_DIR = resolve(ROOT, '..', 'concept-model', 'ontologies', 'taxonomies');
+const OUTPUT = resolve(ROOT, 'src', 'data', 'taxonomies.json');
+
+/**
+ * Minimal Turtle parser for SKOS taxonomy files.
+ * Handles the specific patterns used in our taxonomy TTL files:
+ * - Subject blocks terminated by "."
+ * - Predicate-object pairs separated by ";"
+ * - Quoted strings with @lang tags
+ * - Comma-separated objects
+ */
+function parseTurtle(text) {
+  // Remove comments
+  const cleaned = text.replace(/#[^\n]*/g, '');
+  // Split into subject blocks (terminated by ".")
+  const subjectBlocks = splitSubjects(cleaned);
+
+  const concepts = {};
+  let scheme = null;
+  let schemeLabel = null;
+  let schemeDefinition = null;
+
+  for (const block of subjectBlocks) {
+    const trimmed = block.trim();
+    if (!trimmed) continue;
+
+    // Parse subject and type
+    const subjectMatch = trimmed.match(/^([^\s]+)\s+a\s+(.+?)(?:\s*[;.,]|$)/s);
+    if (!subjectMatch) continue;
+
+    const subject = subjectMatch[1];
+    const types = subjectMatch[2];
+
+    const isScheme = /\bskos:ConceptScheme\b/.test(types);
+    const isConcept = /\bskos:Concept\b/.test(types);
+
+    if (isScheme) {
+      scheme = subject;
+      schemeLabel = findLiteral(trimmed, 'skos:prefLabel');
+      schemeDefinition = findLiteral(trimmed, 'skos:definition');
+    }
+
+    if (isConcept && !isScheme) {
+      const id = subject.includes('/') ? subject.split('/').pop() : subject;
+      const prefLabel = findLiteral(trimmed, 'skos:prefLabel');
+      const altLabel = findLiteral(trimmed, 'skos:altLabel');
+      const definition = findLiteral(trimmed, 'skos:definition');
+      const broader = findResource(trimmed, 'skos:broader');
+
+      concepts[id] = {
+        id,
+        iri: subject,
+        prefLabel: prefLabel || id,
+        ...(altLabel && { altLabel }),
+        ...(definition && { definition }),
+        ...(broader && { broader }),
+      };
+    }
+  }
+
+  return { scheme, schemeLabel, schemeDefinition, concepts };
+}
+
+function splitSubjects(text) {
+  const blocks = [];
+  let depth = 0;
+  let start = -1;
+
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+
+    if (ch === '"') {
+      // Skip quoted strings
+      i++;
+      while (i < text.length && text[i] !== '"') {
+        if (text[i] === '\\') i++;
+        i++;
+      }
+      continue;
+    }
+
+    if (ch === '[') depth++;
+    if (ch === ']') depth--;
+    if (ch === '(') depth++;
+    if (ch === ')') depth--;
+
+    if (depth === 0 && ch === '.' && start >= 0) {
+      blocks.push(text.slice(start, i));
+      start = -1;
+    } else if (start < 0 && ch === '\n') {
+      // Skip blank lines
+      const rest = text.slice(i).trimStart();
+      if (rest && !rest.startsWith('#')) {
+        start = i + 1;
+      }
+    } else if (start < 0 && /[^\s]/.test(ch)) {
+      start = i;
+    }
+  }
+
+  return blocks;
+}
+
+function findLiteral(block, predicate) {
+  // Match: predicate "value"@lang or predicate """value"""@lang
+  const tripleQuoted = new RegExp(predicate + '\\s+"""([^"]*?)"""@en');
+  let m = block.match(tripleQuoted);
+  if (m) return m[1].replace(/\s+/g, ' ').trim();
+
+  const singleQuoted = new RegExp(predicate + '\\s+"([^"]*?)"@en');
+  m = block.match(singleQuoted);
+  return m ? m[1].replace(/\s+/g, ' ').trim() : null;
+}
+
+function findResource(block, predicate) {
+  const re = new RegExp(predicate + '\\s+([^\\s,;]+)');
+  const m = block.match(re);
+  if (!m) return null;
+  const val = m[1].replace(/[;.]+$/, '');
+  return val.includes('/') ? val.split('/').pop() : val;
+}
+
+const TAXONOMY_MAP = {
+  'concept-status.ttl': 'conceptStatus',
+  'entry-status.ttl': 'entryStatus',
+  'normative-status.ttl': 'normativeStatus',
+  'source-type.ttl': 'sourceType',
+  'source-status.ttl': 'sourceStatus',
+  'relationship-type.ttl': 'relationshipType',
+  'designation-type.ttl': 'designationType',
+  'term-type.ttl': 'termType',
+  'grammar-gender.ttl': 'grammarGender',
+  'grammar-number.ttl': 'grammarNumber',
+};
+
+function main() {
+  if (!existsSync(TAXONOMY_DIR)) {
+    console.error(`Taxonomy directory not found: ${TAXONOMY_DIR}`);
+    console.error('Ensure concept-model is available at ../concept-model/');
+    process.exit(1);
+  }
+
+  const result = {};
+
+  for (const [filename, key] of Object.entries(TAXONOMY_MAP)) {
+    const filepath = join(TAXONOMY_DIR, filename);
+    if (!existsSync(filepath)) {
+      console.warn(`  Skipping ${filename} (not found)`);
+      continue;
+    }
+    const text = readFileSync(filepath, 'utf-8');
+    const parsed = parseTurtle(text);
+    result[key] = {
+      scheme: parsed.scheme,
+      schemeLabel: parsed.schemeLabel,
+      schemeDefinition: parsed.schemeDefinition,
+      concepts: parsed.concepts,
+    };
+    const count = Object.keys(parsed.concepts).length;
+    console.log(`  ${key}: ${count} concepts`);
+  }
+
+  mkdirSync(dirname(OUTPUT), { recursive: true });
+  writeFileSync(OUTPUT, JSON.stringify(result, null, 2) + '\n');
+  console.log(`\nWrote ${OUTPUT}`);
+  console.log(`Total taxonomies: ${Object.keys(result).length}`);
+}
+
+main();