@glossarist/concept-browser 0.7.31 → 0.7.33

package/package.json

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

package/scripts/build-edges.js

@@ -5,6 +5,7 @@
  *
  * Usage: node scripts/build-edges.js
  */
+import { extractSourceRefs } from './extract-source-refs.js';
 import { readFileSync, writeFileSync, readdirSync, existsSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
@@ -129,13 +130,14 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
   const conceptsDir = join(datasetDir, 'concepts');
   if (!existsSync(conceptsDir)) {
     console.log(`  Skipping ${registerId}: no concepts directory`);
-    return [];
+    return { edges: [], sourceRefs: [] };
   }
 
   const files = readdirSync(conceptsDir).filter(f => f.endsWith('.json'));
   console.log(`  Processing ${files.length} concepts...`);
 
   const allEdges = [];
+  const allSourceRefs = [];
   const domainConceptCount = new Map();
   let processed = 0;
 
@@ -144,6 +146,7 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
       const data = JSON.parse(readFileSync(join(conceptsDir, file), 'utf-8'));
       const edges = extractAllEdges(data, registerId, uriBase, urnMap);
       allEdges.push(...edges);
+      allSourceRefs.push(...extractSourceRefs(data, registerId));
 
       for (const edge of edges) {
         if (edge.type === 'domain' || edge.type === 'section') {
@@ -241,7 +244,7 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
     console.log(`  Written ${domainNodes.length} edge-derived domain nodes to domain-nodes.json`);
   }
 
-  return deduped;
+  return { edges: deduped, sourceRefs: allSourceRefs };
 }
 
 // Main
@@ -278,6 +281,7 @@ for (const ds of datasets) {
 console.log(`URN resolution map: ${[...urnMap.entries()].map(([k,v]) => `${k}→${v}`).join(', ')}\n`);
 
 const allDatasetEdges = new Map();
+const allSourceRefs = [];
 
 for (const ds of datasets) {
   const manifest = manifestCache.get(ds);
@@ -285,14 +289,52 @@ for (const ds of datasets) {
   try {
     console.log(`${manifest.title} (${ds}):`);
     const uriBase = manifest.uriBase || 'https://glossarist.org';
-    const edges = buildEdgesForDataset(join(DATA_DIR, ds), ds, uriBase, urnMap, manifest);
-    allDatasetEdges.set(ds, edges);
+    const result = buildEdgesForDataset(join(DATA_DIR, ds), ds, uriBase, urnMap, manifest);
+    allDatasetEdges.set(ds, result.edges);
+    allSourceRefs.push(...result.sourceRefs);
   } catch (e) {
     console.error(`Error reading manifest for ${ds}: ${e.message}`);
   }
   console.log();
 }
 
+// Audit — report concept source strings not covered by manifest refs.
+// Bibliography mapping (ref → URN) is declared in register.yaml and flows
+// through manifest.json to datasets.json at generate time. No separate
+// source-refs file needed — the registry IS the single source of truth.
+
+// Build a lookup of all known source strings from manifests
+const knownSourceStrings = new Set();
+for (const [ds, manifest] of manifestCache) {
+  if (manifest.ref) knownSourceStrings.add(manifest.ref);
+  for (const alias of manifest.refAliases ?? []) {
+    knownSourceStrings.add(alias);
+  }
+  if (manifest.datasetUri) knownSourceStrings.add(manifest.datasetUri);
+  for (const alias of manifest.uriAliases ?? []) {
+    const base = alias.endsWith('*') ? alias.slice(0, -1) : alias;
+    knownSourceStrings.add(base);
+  }
+}
+
+const auditUnmatched = new Map();
+for (const { source, registerId } of allSourceRefs) {
+  if (knownSourceStrings.has(source)) continue;
+  // URN source strings resolve via URI routing — not a bibliography concern
+  if (source.startsWith('urn:')) continue;
+  if (!auditUnmatched.has(source)) {
+    auditUnmatched.set(source, registerId);
+  }
+}
+
+if (auditUnmatched.size > 0) {
+  console.warn(`\n⚠ ${auditUnmatched.size} source string(s) in concept data have no matching dataset ref:`);
+  for (const [source, fromDataset] of auditUnmatched) {
+    console.warn(`  "${source}" (from ${fromDataset})`);
+  }
+  console.warn('Add refAliases to the target dataset manifest, or fix source strings to use URNs.\n');
+}
+
 // Build cross-reference index: for each dataset, which other datasets'
 // edges.json contains edges targeting that dataset's URIs.
 const datasetUriPrefixes = new Map();

package/scripts/extract-source-refs.js

@@ -0,0 +1,32 @@
+/**
+ * Source reference extraction for citation linking.
+ *
+ * Scans concept JSON-LD for source strings in gl:source fields.
+ * Used by build-edges.js to generate source-refs.json.
+ */
+
+export function extractSourceRefs(concept, registerId) {
+  const refs = new Set();
+
+  // Managed concept-level sources
+  for (const src of concept['gl:source'] || []) {
+    const origin = src['gl:origin'];
+    if (origin) {
+      const ref = origin['gl:ref'];
+      if (ref?.['gl:source']) refs.add(ref['gl:source']);
+    }
+  }
+
+  // Localized concept-level sources
+  for (const lc of Object.values(concept['gl:localizedConcept'] || {})) {
+    for (const src of lc['gl:source'] || []) {
+      const origin = src['gl:origin'];
+      if (origin) {
+        const ref = origin['gl:ref'];
+        if (ref?.['gl:source']) refs.add(ref['gl:source']);
+      }
+    }
+  }
+
+  return [...refs].map(source => ({ source, registerId }));
+}

package/scripts/generate-data.mjs

@@ -927,6 +927,8 @@ for (let i = 0; i < config.datasets.length; i++) {
     datasetUri: ds.uri || reg?.urn || undefined,
     uriBase: config.uriBase || undefined,
     uriAliases: ds.uriAliases || reg?.urnAliases || undefined,
+    ref: ds.ref || reg?.ref || undefined,
+    refAliases: ds.refAliases || reg?.refAliases || undefined,
   });
 }
 writeJson(path.join(PUBLIC, 'datasets.json'), registry);

package/src/__tests__/citation-display.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import { createPinia, setActivePinia } from 'pinia';
+import CitationDisplay from '../components/CitationDisplay.vue';
+import { getFactory, resetFactory } from '../adapters/factory';
+import { ReferenceResolver } from '../adapters/ReferenceResolver';
+
+// Minimal Citation type matching the glossarist Citation interface
+function makeCitation(source: string, referenceFrom: string, type = 'clause') {
+  return {
+    ref: { source },
+    locality: { type, referenceFrom },
+  };
+}
+
+describe('CitationDisplay — source reference linking', () => {
+  let router: any;
+
+  beforeEach(async () => {
+    resetFactory();
+    const factory = getFactory();
+    // Register dataset patterns
+    factory.resolver.registerDataset('vim-2012', ['urn:oiml:pub:v:2:2012*']);
+    factory.resolver.registerDataset('viml-2022', ['urn:oiml:pub:v:1:2022*']);
+    // Register source refs
+    factory.resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+    factory.resolver.registerSourceRef('OIML V2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+    factory.resolver.registerSourceRef('VIM', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+
+    router = createRouter({
+      history: createMemoryHistory(),
+      routes: [
+        { path: '/', component: { template: '<div/>' } },
+        { name: 'concept', path: '/dataset/:registerId/concept/:conceptId', component: { template: '<div/>' } },
+      ],
+    });
+    await router.push('/');
+    setActivePinia(createPinia());
+  });
+
+  function mountCitation(citation: any, registerId?: string) {
+    return mount(CitationDisplay, {
+      props: { citation, registerId },
+      global: { plugins: [router] },
+    });
+  }
+
+  it('renders source text as plain span when citation cannot be resolved', () => {
+    const wrapper = mountCitation(makeCitation('Unknown Source', '1.1'));
+    expect(wrapper.find('button.concept-link').exists()).toBe(false);
+    expect(wrapper.text()).toContain('Unknown Source');
+  });
+
+  it('renders source text as clickable button when citation resolves', () => {
+    const wrapper = mountCitation(makeCitation('OIML V2-200:2012', '2.2'), 'viml-2022');
+    expect(wrapper.find('button.concept-link').exists()).toBe(true);
+    expect(wrapper.text()).toContain('OIML V2-200:2012');
+  });
+
+  it('renders locality as clickable when citation resolves', () => {
+    const wrapper = mountCitation(makeCitation('OIML V2-200:2012', '2.2'), 'viml-2022');
+    expect(wrapper.text()).toContain('2.2');
+    // The clause type and referenceFrom should be inside a button
+    const buttons = wrapper.findAll('button.concept-link');
+    expect(buttons.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('renders locality as plain text when citation does not resolve', () => {
+    const wrapper = mountCitation(makeCitation('Unknown', '1.1'));
+    expect(wrapper.text()).toContain('1.1');
+    expect(wrapper.find('button.concept-link').exists()).toBe(false);
+  });
+
+  it('renders nothing when citation has no ref', () => {
+    const wrapper = mountCitation({ ref: null, locality: null });
+    expect(wrapper.find('button').exists()).toBe(false);
+  });
+
+  it('renders ref.id when present alongside ref.source', () => {
+    const wrapper = mountCitation({
+      ref: { source: 'Unknown', id: 'ABC-123' },
+      locality: null,
+    });
+    expect(wrapper.text()).toContain('ABC-123');
+  });
+
+  it('renders ref.version when present', () => {
+    const wrapper = mountCitation({
+      ref: { source: 'ISO 9000', version: '2015' },
+      locality: null,
+    });
+    expect(wrapper.text()).toContain('2015');
+  });
+
+  it('shows target hint for resolved cross-dataset citation', () => {
+    const wrapper = mountCitation(makeCitation('VIM', '2.2'), 'viml-2022');
+    const hint = wrapper.text();
+    expect(hint).toContain('→');
+  });
+
+  it('resolves via ref alias', () => {
+    const wrapper = mountCitation(makeCitation('VIM', '2.2'), 'viml-2022');
+    expect(wrapper.find('button.concept-link').exists()).toBe(true);
+  });
+
+  it('renders citation with both source and locality resolved', () => {
+    const wrapper = mountCitation(makeCitation('OIML V 2-200:2012', '5.1'), 'viml-2022');
+    expect(wrapper.find('button.concept-link').exists()).toBe(true);
+    expect(wrapper.text()).toContain('OIML V 2-200:2012');
+    expect(wrapper.text()).toContain('5.1');
+  });
+
+  it('shows cross-dataset arrow indicator for cross-dataset citations', () => {
+    const wrapper = mountCitation(makeCitation('VIM', '2.2'), 'viml-2022');
+    expect(wrapper.text()).toContain('↗');
+  });
+
+  it('does not show cross-dataset arrow for same-dataset citations', () => {
+    // Same dataset: registerId matches resolved target
+    const wrapper = mountCitation(makeCitation('OIML V 2-200:2012', '2.2'), 'vim-2012');
+    expect(wrapper.text()).not.toContain('↗');
+  });
+
+  it('does not show cross-dataset arrow for unresolved citations', () => {
+    const wrapper = mountCitation(makeCitation('Unknown', '1.1'));
+    expect(wrapper.text()).not.toContain('↗');
+  });
+
+  it('renders hover preview elements for resolved citations', () => {
+    const wrapper = mountCitation(makeCitation('VIM', '2.2'), 'viml-2022');
+    // The component should have mouseenter handlers on the button
+    const buttons = wrapper.findAll('button.concept-link');
+    expect(buttons.length).toBeGreaterThanOrEqual(1);
+    // Teleport content is not rendered in test env, but the template structure is present
+    expect(wrapper.html()).toContain('Hover preview');
+  });
+
+  it('does not render preview elements for unresolved citations', () => {
+    const wrapper = mountCitation(makeCitation('Unknown', '1.1'));
+    expect(wrapper.html()).not.toContain('citation-preview');
+  });
+});

package/src/__tests__/concept-helpers.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from 'vitest';
+import { LocalizedConcept, Expression } from 'glossarist';
+import {
+  entryStatusColor,
+  conceptStatusColor,
+  conceptStatusLabel,
+  conceptStatusDefinition,
+  entryStatusLabel,
+  entryStatusDefinition,
+  getPreferredTerm,
+} from '../utils/concept-helpers';
+import { ontology } from '../adapters/ontology-registry';
+
+describe('conceptStatusColor', () => {
+  it('returns correct color for each concept status', () => {
+    expect(conceptStatusColor('valid')).toBe('badge-green');
+    expect(conceptStatusColor('superseded')).toBe('bg-red-50 text-red-700');
+    expect(conceptStatusColor('draft')).toBe('badge-yellow');
+    expect(conceptStatusColor('retired')).toBe('badge-gray');
+    expect(conceptStatusColor('invalid')).toBe('bg-red-50 text-red-700');
+  });
+
+  it('returns badge-gray for null', () => {
+    expect(conceptStatusColor(null)).toBe('badge-gray');
+  });
+
+  it('returns badge-gray for unknown status', () => {
+    expect(conceptStatusColor('nonexistent')).toBe('badge-gray');
+  });
+});
+
+describe('conceptStatusLabel', () => {
+  it('returns label for each concept status', () => {
+    expect(conceptStatusLabel('valid')).toBe('valid');
+    expect(conceptStatusLabel('superseded')).toBe('superseded');
+    expect(conceptStatusLabel('retired')).toBe('retired');
+    expect(conceptStatusLabel('draft')).toBe('draft');
+  });
+
+  it('returns empty string for null', () => {
+    expect(conceptStatusLabel(null)).toBe('');
+  });
+
+  it('returns raw id for unknown status', () => {
+    expect(conceptStatusLabel('unknown_status')).toBe('unknown_status');
+  });
+});
+
+describe('conceptStatusDefinition', () => {
+  it('returns definition for known statuses', () => {
+    const def = conceptStatusDefinition('valid');
+    expect(def).toBeTruthy();
+    expect(typeof def).toBe('string');
+  });
+
+  it('returns null for null', () => {
+    expect(conceptStatusDefinition(null)).toBeNull();
+  });
+});
+
+describe('entryStatusColor', () => {
+  it('returns correct color for each entry status', () => {
+    expect(entryStatusColor('valid')).toBe('badge-green');
+    expect(entryStatusColor('not_valid')).toBe('bg-red-50 text-red-700');
+    expect(entryStatusColor('draft')).toBe('badge-yellow');
+  });
+
+  it('returns badge-gray for unknown status', () => {
+    expect(entryStatusColor('nonexistent')).toBe('badge-gray');
+  });
+});
+
+describe('entryStatusLabel', () => {
+  it('returns label for each entry status', () => {
+    expect(entryStatusLabel('valid')).toBe('valid');
+    expect(entryStatusLabel('not_valid')).toBe('not valid');
+    expect(entryStatusLabel('draft')).toBe('draft');
+  });
+
+  it('returns empty string for null', () => {
+    expect(entryStatusLabel(null)).toBe('');
+  });
+});
+
+describe('entryStatusDefinition', () => {
+  it('returns definition for known statuses', () => {
+    const def = entryStatusDefinition('valid');
+    expect(def).toBeTruthy();
+  });
+
+  it('returns null for null', () => {
+    expect(entryStatusDefinition(null)).toBeNull();
+  });
+});
+
+describe('getPreferredTerm', () => {
+  it('returns primary designation when set', () => {
+    const lc = LocalizedConcept.fromJSON({
+      language_code: 'eng',
+      terms: [
+        { designation: 'preferred term', type: 'expression', normative_status: 'preferred' },
+        { designation: 'admitted term', type: 'expression', normative_status: 'admitted' },
+      ],
+    });
+    expect(getPreferredTerm(lc)).toBe('preferred term');
+  });
+
+  it('returns first term when no primary designation', () => {
+    const lc = LocalizedConcept.fromJSON({
+      language_code: 'eng',
+      terms: [{ designation: 'only term', type: 'expression' }],
+    });
+    expect(getPreferredTerm(lc)).toBe('only term');
+  });
+
+  it('returns fallback for null', () => {
+    expect(getPreferredTerm(null)).toBe('—');
+    expect(getPreferredTerm(null, 'N/A')).toBe('N/A');
+  });
+
+  it('returns fallback for undefined', () => {
+    expect(getPreferredTerm(undefined)).toBe('—');
+  });
+
+  it('returns fallback when no terms', () => {
+    const lc = LocalizedConcept.fromJSON({ language_code: 'eng' });
+    expect(getPreferredTerm(lc)).toBe('—');
+  });
+});

package/src/__tests__/designation-relationship.test.ts

@@ -42,7 +42,7 @@ describe('designation relationship bridge', () => {
 
     const rc = term.related[0];
     expect(rc.type).toBe('abbreviated_form_for');
-    expect(getDesignationTarget(rc)).toBe('Portable Document Format');
+    expect(getDesignationTarget(rc as any)).toBe('Portable Document Format');
   });
 
   it('returns null for concept-level relationships (no target)', () => {
@@ -50,7 +50,7 @@ describe('designation relationship bridge', () => {
     const concept = conceptFromJson(doc);
     const rc = concept.localization('eng')!.terms[0].related[0];
     expect(rc.type).toBe('abbreviated_form_for');
-    expect(getDesignationTarget(rc)).toBeNull();
+    expect(getDesignationTarget(rc as any)).toBeNull();
   });
 
   it('handles short_form_for designation target', () => {
@@ -58,7 +58,7 @@ describe('designation relationship bridge', () => {
     const concept = conceptFromJson(doc);
     const rc = concept.localization('eng')!.terms[0].related[0];
     expect(rc.type).toBe('short_form_for');
-    expect(getDesignationTarget(rc)).toBe('kilogram');
+    expect(getDesignationTarget(rc as any)).toBe('kilogram');
   });
 
   it('preserves designation target from glossarist native format', () => {
@@ -78,7 +78,7 @@ describe('designation relationship bridge', () => {
     };
     const concept = conceptFromJson(doc);
     const rc = concept.localization('eng')!.terms[0].related[0];
-    expect(getDesignationTarget(rc)).toBe('Portable Document Format');
+    expect(getDesignationTarget(rc as any)).toBe('Portable Document Format');
   });
 
   it('designation without related returns empty related array', () => {
@@ -171,6 +171,37 @@ describe('ConceptRef text bridge', () => {
   });
 });
 
+// ── Robustness: matching by designation string, not array index ────────────
+
+describe('designation target matching robustness', () => {
+  it('matches designation targets correctly even when raw terms are reordered', () => {
+    const doc = {
+      id: '1',
+      localizations: {
+        eng: {
+          language_code: 'eng',
+          terms: [
+            { designation: 'PDF', type: 'abbreviation', related: [{ type: 'abbreviated_form_for', target: 'Portable Document Format' }] },
+            { designation: 'ISO', type: 'abbreviation', related: [{ type: 'abbreviated_form_for', target: 'International Organization for Standardization' }] },
+          ],
+          definition: [{ content: 'test' }],
+        },
+      },
+    };
+    // Reverse the raw terms to simulate reordering
+    const rawTerms = doc.localizations.eng.terms.slice().reverse();
+    doc.localizations.eng.terms = rawTerms;
+
+    const concept = conceptFromJson(doc);
+    const lc = concept.localization('eng')!;
+    // Terms are in model order, not raw order
+    const pdf = lc.terms.find(t => t.designation === 'PDF')!;
+    const iso = lc.terms.find(t => t.designation === 'ISO')!;
+    expect(getDesignationTarget(pdf.related[0])).toBe('Portable Document Format');
+    expect(getDesignationTarget(iso.related[0])).toBe('International Organization for Standardization');
+  });
+});
+
 // ── Generate-data serialization ────────────────────────────────────────────
 
 describe('generate-data designation serialization', () => {

package/src/__tests__/extract-source-refs.test.ts

@@ -0,0 +1,136 @@
+// @ts-nocheck — ESM .js import without type declarations
+import { describe, it, expect } from 'vitest';
+import { extractSourceRefs } from '../../scripts/extract-source-refs.js';
+
+function makeConcept(sources: any[], localizedSources?: any) {
+  return {
+    '@id': 'https://glossarist.org/ds1/concept/1.1',
+    'gl:source': sources || [],
+    'gl:localizedConcept': localizedSources || {},
+  };
+}
+
+function makeSource(source: string, refFrom: string, type = 'authoritative') {
+  return {
+    'gl:origin': {
+      'gl:ref': { 'gl:source': source },
+      'gl:locality': { 'gl:type': type, 'gl:referenceFrom': refFrom },
+    },
+  };
+}
+
+describe('extractSourceRefs', () => {
+  it('extracts source from managed concept-level gl:source', () => {
+    const concept = makeConcept([makeSource('OIML V2-200:2012', '2.2')]);
+    const result = extractSourceRefs(concept, 'viml-2022');
+    expect(result).toEqual([{ source: 'OIML V2-200:2012', registerId: 'viml-2022' }]);
+  });
+
+  it('extracts source from localized concept gl:source', () => {
+    const concept = makeConcept([], {
+      eng: { 'gl:source': [makeSource('ISO/IEC 17000:2020', '3.1')] },
+    });
+    const result = extractSourceRefs(concept, 'viml-2022');
+    expect(result).toEqual([{ source: 'ISO/IEC 17000:2020', registerId: 'viml-2022' }]);
+  });
+
+  it('extracts from both managed and localized sources', () => {
+    const concept = makeConcept(
+      [makeSource('OIML V2-200:2012', '2.2')],
+      {
+        eng: { 'gl:source': [makeSource('ISO/IEC 17000:2020', '3.1')] },
+        fra: { 'gl:source': [makeSource('ISO/CEI 17000:2020', '3.1')] },
+      },
+    );
+    const result = extractSourceRefs(concept, 'viml-2022');
+    expect(result).toEqual([
+      { source: 'OIML V2-200:2012', registerId: 'viml-2022' },
+      { source: 'ISO/IEC 17000:2020', registerId: 'viml-2022' },
+      { source: 'ISO/CEI 17000:2020', registerId: 'viml-2022' },
+    ]);
+  });
+
+  it('deduplicates identical source strings', () => {
+    const concept = makeConcept(
+      [makeSource('VIM', '2.2')],
+      { eng: { 'gl:source': [makeSource('VIM', '2.3')] } },
+    );
+    const result = extractSourceRefs(concept, 'viml-2022');
+    expect(result).toEqual([{ source: 'VIM', registerId: 'viml-2022' }]);
+  });
+
+  it('returns empty array when no sources present', () => {
+    const concept = makeConcept();
+    const result = extractSourceRefs(concept, 'viml-2022');
+    expect(result).toEqual([]);
+  });
+
+  it('returns empty array for concept with no gl:source field', () => {
+    const concept = { '@id': 'https://glossarist.org/ds1/concept/1.1' };
+    const result = extractSourceRefs(concept, 'viml-2022');
+    expect(result).toEqual([]);
+  });
+
+  it('skips sources without gl:origin', () => {
+    const concept = makeConcept([{ 'gl:ref': { 'gl:source': 'VIM' } }]);
+    const result = extractSourceRefs(concept, 'ds1');
+    expect(result).toEqual([]);
+  });
+
+  it('skips origins without gl:ref', () => {
+    const concept = makeConcept([{ 'gl:origin': { 'gl:locality': {} } }]);
+    const result = extractSourceRefs(concept, 'ds1');
+    expect(result).toEqual([]);
+  });
+
+  it('skips refs without gl:source', () => {
+    const concept = makeConcept([{ 'gl:origin': { 'gl:ref': { 'gl:id': '2.2' } } }]);
+    const result = extractSourceRefs(concept, 'ds1');
+    expect(result).toEqual([]);
+  });
+
+  it('handles concept with multiple localized languages', () => {
+    const concept = makeConcept([], {
+      eng: { 'gl:source': [makeSource('OIML V 1:2022', '0.01')] },
+      fra: { 'gl:source': [makeSource('OIML V 1:2022', '0.01')] },
+    });
+    const result = extractSourceRefs(concept, 'viml-2022');
+    expect(result).toEqual([{ source: 'OIML V 1:2022', registerId: 'viml-2022' }]);
+  });
+
+  it('preserves registerId from the caller, not the concept data', () => {
+    const concept = makeConcept([makeSource('VIM', '2.2')]);
+    const result = extractSourceRefs(concept, 'my-dataset');
+    expect(result[0].registerId).toBe('my-dataset');
+  });
+
+  it('handles source strings with special characters', () => {
+    const concept = makeConcept([makeSource('OIML V 2:1993', '3.6')]);
+    const result = extractSourceRefs(concept, 'vim-1993');
+    expect(result).toEqual([{ source: 'OIML V 2:1993', registerId: 'vim-1993' }]);
+  });
+
+  it('handles source strings with whitespace variations', () => {
+    const concept = makeConcept([makeSource('ISO/ CEI 17000:2004', '3.1')]);
+    const result = extractSourceRefs(concept, 'viml-2013');
+    expect(result).toEqual([{ source: 'ISO/ CEI 17000:2004', registerId: 'viml-2013' }]);
+  });
+
+  it('extracts from multiple sources in a single concept', () => {
+    const concept = makeConcept([
+      makeSource('OIML V2-200:2012', '2.2'),
+      makeSource('ISO/IEC 17000:2020', '3.1'),
+    ]);
+    const result = extractSourceRefs(concept, 'viml-2022');
+    expect(result).toEqual([
+      { source: 'OIML V2-200:2012', registerId: 'viml-2022' },
+      { source: 'ISO/IEC 17000:2020', registerId: 'viml-2022' },
+    ]);
+  });
+
+  it('extracts URN-based source strings', () => {
+    const concept = makeConcept([makeSource('urn:oiml:pub:v:2:2012', '2.2')]);
+    const result = extractSourceRefs(concept, 'viml-2022');
+    expect(result).toEqual([{ source: 'urn:oiml:pub:v:2:2012', registerId: 'viml-2022' }]);
+  });
+});

package/src/__tests__/factory-lazy.test.ts

@@ -89,7 +89,7 @@ describe('AdapterFactory — lazy discovery', () => {
 
     expect(adapters.length).toBe(1);
     expect(adapters[0].manifest!.title).toBe('Full Dataset');
-    // Should fetch both datasets.json and manifest.json
+    // Should fetch datasets.json and manifest.json
     expect(mockFetch).toHaveBeenCalledTimes(2);
   });
 
@@ -140,7 +140,7 @@ describe('AdapterFactory — lazy discovery', () => {
       return Promise.resolve({ ok: false, status: 404 } as Response);
     });
 
-    // Discover with summary — no manifest fetch
+    // Discover with summary — only datasets.json fetched
     const adapters = await factory.discoverDatasets('/datasets.json');
     expect(adapters[0].manifest!.title).toBe('Summary Title');
     expect(mockFetch).toHaveBeenCalledTimes(1);