@glossarist/concept-browser 0.7.35 → 0.7.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.35",
+  "version": "0.7.37",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -25,7 +25,7 @@
     "autoprefixer": "^10.4.21",
     "d3": "^7.9.0",
     "favicons": "^7.2.0",
-    "glossarist": "^0.3.3",
+    "glossarist": "^0.3.7",
     "js-yaml": "^4.1.0",
     "pinia": "^2.3.1",
     "postcss": "^8.5.3",

package/scripts/build-edges.js

@@ -31,14 +31,16 @@ function extractReferences(concept, registerId) {
     if (lc['gl:references']) {
       for (const ref of lc['gl:references']) {
         if (ref['@id'] && ref['@id'] !== sourceUri) {
-          edges.push({
+          const edge = {
             source: sourceUri,
             target: ref['@id'],
-            type: 'references',
+            type: ref['@id'].startsWith('cite:') ? 'citation' : 'references',
             label: ref['gl:term'] || undefined,
             register: registerId,
             lang,
-          });
+          };
+          if (ref['gl:sourceId']) edge.sourceId = ref['gl:sourceId'];
+          edges.push(edge);
         }
       }
     }
@@ -263,7 +265,7 @@ const datasets = readdirSync(DATA_DIR).filter(f => {
   }
 });
 
-// Build URN→datasetId map from all manifests
+// Build URI→datasetId prefix map from all manifests
 const urnMap = new Map();
 const manifestCache = new Map();
 for (const ds of datasets) {
@@ -271,14 +273,17 @@ for (const ds of datasets) {
   try {
     const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
     manifestCache.set(ds, manifest);
-    if (manifest.datasetUri) urnMap.set(manifest.datasetUri, ds);
+    if (manifest.datasetUri) {
+      const base = manifest.datasetUri.endsWith('*') ? manifest.datasetUri.slice(0, -1) : manifest.datasetUri;
+      if (base) urnMap.set(base, ds);
+    }
     for (const alias of manifest.uriAliases ?? []) {
       const base = alias.endsWith('*') ? alias.slice(0, -1) : alias;
-      if (base.startsWith('urn:')) urnMap.set(base, ds);
+      if (base) urnMap.set(base, ds);
     }
   } catch {}
 }
-console.log(`URN resolution map: ${[...urnMap.entries()].map(([k,v]) => `${k}→${v}`).join(', ')}\n`);
+console.log(`URI resolution map: ${[...urnMap.entries()].map(([k,v]) => `${k}→${v}`).join(', ')}\n`);
 
 const allDatasetEdges = new Map();
 const allSourceRefs = [];
@@ -310,7 +315,10 @@ for (const [ds, manifest] of manifestCache) {
   for (const alias of manifest.refAliases ?? []) {
     knownSourceStrings.add(alias);
   }
-  if (manifest.datasetUri) knownSourceStrings.add(manifest.datasetUri);
+  if (manifest.datasetUri) {
+    const base = manifest.datasetUri.endsWith('*') ? manifest.datasetUri.slice(0, -1) : manifest.datasetUri;
+    knownSourceStrings.add(base);
+  }
   for (const alias of manifest.uriAliases ?? []) {
     const base = alias.endsWith('*') ? alias.slice(0, -1) : alias;
     knownSourceStrings.add(base);

package/scripts/generate-data.mjs

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import yaml from 'js-yaml';
-import { naturalSort, Register } from 'glossarist';
+import { naturalSort, Register, parseMention } from 'glossarist';
 import { loadSiteConfig } from './load-site-config.mjs';
 
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
@@ -19,6 +19,11 @@ function readYaml(filePath) {
   return yaml.load(fs.readFileSync(filePath, 'utf8'));
 }
 
+/** Strip HTML tags and normalize whitespace for plain-text display. */
+function stripHtml(s) {
+  return s.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim();
+}
+
 function loadConceptFile(filePath) {
   const content = fs.readFileSync(filePath, 'utf8');
   const docs = yaml.loadAll(content, null, { schema: yaml.DEFAULT_SCHEMA });
@@ -136,36 +141,43 @@ function defsToJsonLd(defs) {
     .filter(d => d['gl:content']);
 }
 
+function refToJsonLd(ref) {
+  if (!ref) return undefined;
+  const refObj = { '@type': 'gl:Ref' };
+  if (typeof ref === 'string') {
+    refObj['gl:source'] = ref;
+  } else {
+    if (ref.source) refObj['gl:source'] = ref.source;
+    if (ref.id) refObj['gl:id'] = ref.id;
+    if (ref.version) refObj['gl:version'] = ref.version;
+  }
+  return refObj;
+}
+
+function localityToJsonLd(loc) {
+  if (!loc) return undefined;
+  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;
+  return Object.keys(locObj).length > 0 ? locObj : undefined;
+}
+
 function sourcesToJsonLd(sources) {
   if (!sources || !Array.isArray(sources)) return [];
   return sources.map(s => {
     const doc = { '@type': 'gl:ConceptSource' };
+    if (s.id) doc['gl:id'] = s.id;
     if (s.type) doc['gl:sourceType'] = s.type;
     if (s.status) doc['gl:sourceStatus'] = s.status;
     if (s.origin) {
       const origin = { '@type': 'gl:Citation' };
-      if (s.origin.ref) {
-        const ref = s.origin.ref;
-        const refObj = { '@type': 'gl:Ref' };
-        if (typeof ref === 'string') {
-          refObj['gl:source'] = ref;
-        } else {
-          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;
-      }
+      const ref = refToJsonLd(s.origin.ref);
+      if (ref) origin['gl:ref'] = ref;
+      const loc = localityToJsonLd(s.origin.locality);
+      if (loc) origin['gl:locality'] = loc;
       if (s.origin.link) origin['gl:link'] = s.origin.link;
       doc['gl:origin'] = origin;
     }
@@ -176,7 +188,12 @@ function sourcesToJsonLd(sources) {
 function refsToJsonLd(refs, refMaps) {
   if (!refs || !Array.isArray(refs)) return [];
   return refs.map(r => {
-    if (r.id) return { '@id': r.id, 'gl:term': r.term };
+    if (r.id) {
+      const ref = { '@id': r.id, 'gl:term': r.term };
+      if (r.sourceId) ref['gl:sourceId'] = r.sourceId;
+      if (r.citation) ref['gl:citation'] = citationToJsonLd(r.citation);
+      return ref;
+    }
     if (r.term && refMaps) {
       const uri = resolveRefUri(r.term, refMaps);
       if (uri) return { '@id': uri, 'gl:term': r.term };
@@ -185,34 +202,70 @@ function refsToJsonLd(refs, refMaps) {
   }).filter(r => r['@id']);
 }
 
-function resolveRefUri(term, refMaps) {
-  const base = refMaps.uriBase;
-  const urnPrefix = 'urn:iso:std:iso:';
-  if (term.startsWith(urnPrefix)) {
-    const rest = term.slice(urnPrefix.length);
-    const match = rest.match(/^(\d+):(.+)$/);
-    if (match) {
-      const dsId = refMaps.urnStandardMap[match[1]];
-      if (dsId) return `${base}/${dsId}/concept/${match[2]}`;
+function citationToJsonLd(citation) {
+  const obj = {};
+  const ref = refToJsonLd(citation.ref);
+  if (ref) obj['gl:ref'] = ref;
+  const loc = localityToJsonLd(citation.locality);
+  if (loc) obj['gl:locality'] = loc;
+  if (citation.link) obj['gl:link'] = citation.link;
+  return obj;
+}
+
+function buildPatternIndex(datasets, registerCache) {
+  const entries = [];
+
+  for (const ds of datasets) {
+    const reg = registerCache[ds.id] || null;
+    const patterns = new Set();
+
+    // Site-config patterns (primary)
+    if (ds.uri) patterns.add(ds.uri);
+    for (const alias of ds.uriAliases || []) patterns.add(alias);
+
+    // Register.yaml patterns (supplementary)
+    if (reg) {
+      if (reg.urn && reg.urn.endsWith('*')) patterns.add(reg.urn);
+      for (const alias of reg.urnAliases || []) patterns.add(alias);
     }
+
+    for (const pattern of patterns) {
+      if (!pattern.endsWith('*')) continue;
+      const prefix = pattern.slice(0, -1);
+      if (prefix) entries.push({ prefix, datasetId: ds.id });
+    }
+  }
+
+  // Sort longest prefix first for correct longest-prefix matching
+  entries.sort((a, b) => b.prefix.length - a.prefix.length);
+
+  function resolve(uri) {
+    for (const { prefix, datasetId } of entries) {
+      if (uri.startsWith(prefix)) {
+        return { datasetId, conceptId: uri.slice(prefix.length) };
+      }
+    }
+    return null;
   }
+
+  return { resolve, entries };
+}
+
+function resolveRefUri(term, refMaps) {
+  const resolved = refMaps.patternIndex.resolve(term);
+  if (resolved) return `${refMaps.uriBase}/${resolved.datasetId}/concept/${resolved.conceptId}`;
+
   const ievMatch = term.match(/^IEV:(\d+[-\d]+)$/);
   if (ievMatch) {
     const dsId = refMaps.refPrefixMap['IEV'];
-    if (dsId) return `${base}/${dsId}/concept/${ievMatch[1]}`;
+    if (dsId) return `${refMaps.uriBase}/${dsId}/concept/${ievMatch[1]}`;
   }
   return null;
 }
 
-function buildRefMaps(config) {
+function buildRefMaps(config, registerCache) {
   const refPrefixMap = {};
-  const urnStandardMap = {};
-
-  for (const ds of config.datasets) {
-    const uri = ds.uri || '';
-    const urnMatch = uri.match(/^urn:iso:std:iso:(\d+):\*$/);
-    if (urnMatch) urnStandardMap[urnMatch[1]] = ds.id;
-  }
+  const patternIndex = buildPatternIndex(config.datasets, registerCache);
 
   for (const route of config.routing || []) {
     if (route.uri && route.uri.includes('iec') && route.uri.includes('60050')) {
@@ -223,56 +276,172 @@ function buildRefMaps(config) {
 
   const xref = config.crossReferences || {};
   if (xref.refPrefixMap) Object.assign(refPrefixMap, xref.refPrefixMap);
-  if (xref.urnStandardMap) Object.assign(urnStandardMap, xref.urnStandardMap);
 
   const uriBase = config.uriBase || `https://${config.domain}`;
-  return { refPrefixMap, urnStandardMap, uriBase, register: null };
+  return { patternIndex, refPrefixMap, uriBase, register: null };
 }
 
-function extractInlineRefs(localizedData, refMaps) {
-  const refs = [];
-  const texts = [];
-  const { refPrefixMap, urnStandardMap, uriBase } = refMaps;
 
-  if (localizedData.definition) {
-    const defs = Array.isArray(localizedData.definition) ? localizedData.definition : [localizedData.definition];
-    for (const d of defs) texts.push(typeof d === 'string' ? d : (d.content || ''));
-  }
-  if (localizedData.notes) {
-    for (const n of localizedData.notes) texts.push(typeof n === 'string' ? n : (n.content || ''));
-  }
-  if (localizedData.examples) {
-    for (const e of localizedData.examples) texts.push(typeof e === 'string' ? e : (e.content || ''));
+// ── Mention handlers (OCP: add new mention kinds by adding handlers) ─────
+
+/**
+ * Resolve an IEV:NNN-NN-NN display form to a concept URI.
+ */
+function resolveIevRef(display, term, refPrefixMap, uriBase) {
+  if (!display.startsWith('IEV:')) return null;
+  const datasetId = refPrefixMap['IEV'];
+  if (!datasetId) return null;
+  return { id: `${uriBase}/${datasetId}/concept/${display.slice(4)}`, term };
+}
+
+/**
+ * Resolve a URI identifier via the pattern index.
+ */
+function resolvePatternRef(identifier, display, refPrefixMap, patternIndex, uriBase) {
+  const r = patternIndex.resolve(identifier);
+  if (!r) return null;
+  return { id: `${uriBase}/${r.datasetId}/concept/${r.conceptId}`, term: display };
+}
+
+/**
+ * Handle a cite-ref mention: links to a ConceptSource entry.
+ */
+function handleCiteRef(parsed, allSources) {
+  const sourceEntry = allSources.find(s => s.id === parsed.key);
+  if (sourceEntry) {
+    return {
+      id: `cite:${sourceEntry.id}`,
+      term: parsed.label || sourceEntry.origin?.toString?.() || sourceEntry.id,
+      sourceId: sourceEntry.id,
+      citation: sourceEntry.origin || null,
+    };
   }
-  const fullText = texts.join(' ');
+  return {
+    id: `cite:${parsed.key}`,
+    term: parsed.label || parsed.key,
+    sourceId: parsed.key,
+    citation: null,
+  };
+}
+
+/**
+ * Handle a numeric mention: bare concept ID in same dataset.
+ */
+function handleNumeric(parsed, register, uriBase) {
+  if (!register) return null;
+  const term = parsed.label ?? parsed.id;
+  return { id: `${uriBase}/${register}/concept/${parsed.id}`, term };
+}
+
+/**
+ * Handle a designation mention (glossarist >= 0.3.7):
+ * {{designation,render term}} — resolve designation to concept ID in same dataset.
+ * Falls back to the raw designation as the concept ID if no lookup table exists.
+ */
+function handleDesignation(parsed, refMaps) {
+  const register = refMaps.register;
+  if (!register) return null;
+  const designation = parsed.id;
+  const display = parsed.label ?? designation;
+  const conceptId = refMaps.designationLookup?.get(designation.toLowerCase());
+  return {
+    id: `${refMaps.uriBase}/${register}/concept/${conceptId ?? designation}`,
+    term: display,
+  };
+}
 
-  for (const m of fullText.matchAll(/\{\{([^,}]+),\s*IEV:([^}]+)\}\}/g)) {
-    const datasetId = refPrefixMap['IEV'];
-    if (datasetId) refs.push({ id: `${uriBase}/${datasetId}/concept/${m[2]}`, term: m[1].trim() });
+/**
+ * Handle an unresolved double-brace mention: try two-arg form.
+ * Format: {{conceptId, displayTerm}} — concept ID first, render term last.
+ */
+function handleUnresolved(body, refMaps) {
+  const commaMatch = body.match(/^([^,}]+),\s*(.+)$/);
+  if (!commaMatch) return null;
+  const identifier = commaMatch[1].trim();
+  const display = commaMatch[2].trim();
+
+  // IEV shortform: {{IEV:shortform, display_term}}
+  const iev = resolveIevRef(identifier, display, refMaps.refPrefixMap, refMaps.uriBase);
+  if (iev) return iev;
+
+  // URI pattern match
+  const pattern = resolvePatternRef(identifier, display, refMaps.refPrefixMap, refMaps.patternIndex, refMaps.uriBase);
+  if (pattern) return pattern;
+
+  // Same-dataset: {{conceptId, displayTerm}} where conceptId is numeric/X.Y
+  const register = refMaps.register;
+  if (register && (/^\d/.test(identifier) || /^[A-Z]\.\d/.test(identifier))) {
+    return { id: `${refMaps.uriBase}/${register}/concept/${identifier}`, term: display };
   }
+  return null;
+}
 
-  for (const m of fullText.matchAll(/\{urn:iso:std:iso:(\d+):([^,}]+),([^,}]+)(?:,([^}]+))?\}/g)) {
-    const datasetId = urnStandardMap[m[1]];
-    if (datasetId) refs.push({ id: `${uriBase}/${datasetId}/concept/${m[2]}`, term: (m[4] || m[3]).trim() });
+// ── Inline reference extraction ───────────────────────────────────────────
+
+function collectTextContent(localizedData) {
+  const texts = [];
+  const textFields = ['definition', 'notes', 'examples'];
+  for (const field of textFields) {
+    const items = localizedData[field];
+    if (!items) continue;
+    const arr = Array.isArray(items) ? items : [items];
+    for (const item of arr) {
+      texts.push(typeof item === 'string' ? item : (item.content || ''));
+    }
   }
+  return texts.join(' ');
+}
 
-  for (const m of fullText.matchAll(/\{\{urn:iso:std:iso:(\d+):([^,}]+),([^,}]+)(?:,([^}]+))?\}\}/g)) {
-    const datasetId = urnStandardMap[m[1]];
-    if (datasetId) refs.push({ id: `${uriBase}/${datasetId}/concept/${m[2]}`, term: (m[4] || m[3]).trim() });
+function extractInlineRefs(localizedData, refMaps, conceptSources = []) {
+  const refs = [];
+  const { refPrefixMap, patternIndex, uriBase } = refMaps;
+  const fullText = collectTextContent(localizedData);
+  const allSources = [...(localizedData.sources || []), ...conceptSources];
+
+  // Single-brace mentions: {uri,display} (not {{...}})
+  for (const m of fullText.matchAll(/\{([^,}]+),([^,}]+)(?:,([^}]+))?\}/g)) {
+    const identifier = m[1].trim();
+    const display = m[2].trim();
+    const altDisplay = (m[3] || '').trim();
+    if (!identifier || !display) continue;
+
+    const iev = resolveIevRef(display, identifier, refPrefixMap, uriBase);
+    if (iev) { refs.push(iev); continue; }
+
+    const pattern = resolvePatternRef(identifier, altDisplay || display, refPrefixMap, patternIndex, uriBase);
+    if (pattern) { refs.push(pattern); }
   }
 
-  // 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 });
+  // Double-brace mentions: dispatched by parseMention kind
+  for (const m of fullText.matchAll(/\{\{([^{}]+?)\}\}/g)) {
+    const body = m[1];
+    const parsed = parseMention(body);
+
+    let ref = null;
+    if (parsed.kind === 'cite-ref') {
+      ref = handleCiteRef(parsed, allSources);
+    } else if (parsed.kind === 'numeric') {
+      ref = handleNumeric(parsed, refMaps.register, uriBase);
+    } else if (parsed.kind === 'urn-ref') {
+      // {{urn:...,render term}} — resolve URN via pattern index (cross-dataset)
+      const uri = parsed.uri;
+      const term = parsed.label ?? uri;
+      const pattern = refMaps.patternIndex.resolve(uri);
+      if (pattern) {
+        ref = { id: `${refMaps.uriBase}/${pattern.datasetId}/concept/${pattern.conceptId}`, term };
+      } else {
+        ref = { id: uri, term };
+      }
+    } else if (parsed.kind === 'designation') {
+      // {{designation,render term}} — same-dataset designation reference
+      ref = handleDesignation(parsed, refMaps);
+    } else {
+      ref = handleUnresolved(body, refMaps);
     }
+    if (ref) refs.push(ref);
   }
 
+  // Deduplicate by id
   const seen = new Set();
   return refs.filter(r => {
     if (seen.has(r.id)) return false;
@@ -333,7 +502,7 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
     if (lc.references && lc.references.length > 0) {
       lDoc['gl:references'] = refsToJsonLd(lc.references, refMaps);
     } else if (refMaps) {
-      const inlineRefs = extractInlineRefs(lc, refMaps);
+      const inlineRefs = extractInlineRefs(lc, refMaps, conceptYaml._sources);
       if (inlineRefs.length > 0) {
         lDoc['gl:references'] = refsToJsonLd(inlineRefs, refMaps);
       }
@@ -632,7 +801,28 @@ function processDataset(dir, register, opts) {
   const langTermCounts = {};
   const langDefCounts = {};
   const availableFormats = ['ttl', 'jsonld', 'yaml', 'tbx'];
-  const dsRefMaps = { ...refMaps, register };
+
+  // Pre-scan: build designation → concept ID lookup for same-dataset designation refs
+  const designationLookup = new Map();
+  for (const file of files) {
+    try {
+      const conceptYaml = loadConceptFile(path.join(dir, file));
+      if (!conceptYaml?.termid) continue;
+      const termid = String(conceptYaml.termid);
+      for (const lang of Object.keys(conceptYaml)) {
+        const lc = conceptYaml[lang];
+        if (!lc || typeof lc !== 'object' || !Array.isArray(lc.terms)) continue;
+        for (const term of lc.terms) {
+          const designation = term.designation;
+          if (typeof designation === 'string' && designation && !designationLookup.has(designation.toLowerCase())) {
+            designationLookup.set(designation.toLowerCase(), termid);
+          }
+        }
+      }
+    } catch {}
+  }
+
+  const dsRefMaps = { ...refMaps, register, designationLookup };
 
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
@@ -707,15 +897,22 @@ function processDataset(dir, register, opts) {
   }));
 
   // Strip HTML from index summary for text display
-  const plainSummary = summary.map(c => ({
-    ...c,
-    eng: c.eng.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim(),
-  }));
+  const plainSummary = summary.map(c => {
+    const designations = {};
+    for (const [lang, term] of Object.entries(c.designations)) {
+      if (term) designations[lang] = stripHtml(term);
+    }
+    return {
+      ...c,
+      designations,
+      eng: stripHtml(c.eng),
+    };
+  });
 
   const graphNodeEntries = concepts.map(c => {
     const cleanDesignations = {};
     for (const [l, t] of Object.entries(c.designations)) {
-      if (t) cleanDesignations[l] = t.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim();
+      if (t) cleanDesignations[l] = stripHtml(t);
     }
     return [c.id, cleanDesignations, c.status];
   });
@@ -845,12 +1042,11 @@ function processDataset(dir, register, opts) {
 console.log('Generating Glossarist vocabulary browser data...\n');
 
 const { config } = loadSiteConfig();
-const refMaps = buildRefMaps(config);
 const counts = {};
 const registry = [];
 const registerCache = {};
 
-// Pre-load all register.yaml files
+// Pre-load all register.yaml files (needed before buildRefMaps for URI pattern indexing)
 for (const ds of config.datasets) {
   const registerDir = path.join(ROOT, '.datasets', ds.id);
   const registerYamlPath = path.join(registerDir, 'register.yaml');
@@ -864,6 +1060,8 @@ for (const ds of config.datasets) {
   }
 }
 
+const refMaps = buildRefMaps(config, registerCache);
+
 for (let i = 0; i < config.datasets.length; i++) {
   const ds = config.datasets[i];
 
@@ -937,8 +1135,8 @@ writeJson(path.join(PUBLIC, 'datasets.json'), registry);
 const configuredIds = new Set(config.datasets.map(d => d.id));
 if (fs.existsSync(DATA)) {
   for (const entry of fs.readdirSync(DATA)) {
-    if (!configuredIds.has(entry)) {
       const stalePath = path.join(DATA, entry);
+    if (!configuredIds.has(entry) && fs.statSync(stalePath).isDirectory()) {
       fs.rmSync(stalePath, { recursive: true, force: true });
       console.log(`  Removed stale data directory: ${entry}`);
     }