@glossarist/concept-browser 0.7.35 → 0.7.37

package/src/__tests__/sidebar-nav-highlighting.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import AppSidebar from '../components/AppSidebar.vue';
+import { useVocabularyStore } from '../stores/vocabulary';
+
+function makeManifest(id = 'test') {
+  return { id, datasetUri: `https://glossarist.org/${id}/concept`, title: `Test ${id}`, description: 'A test dataset',
+    owner: 'ISO', baseUrl: `/data/${id}`, languages: ['eng'], conceptCount: 50,
+    conceptUrlTemplate: `/data/${id}/concepts/{id}.json`, indexUrl: `/data/${id}/index.json`,
+    contextUrl: `/data/${id}/context.json`, uriBase: 'https://glossarist.org', status: 'published',
+    schemaVersion: '1.0', tags: [], lastUpdated: '2025-01-01', sourceRepo: 'https://example.com/repo',
+    chunkSize: 1000, color: '#3366ff' } as any;
+}
+
+function createTestRouter(initialPath = '/') {
+  return createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId', name: 'dataset', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/concept/:conceptId', name: 'concept', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/stats', name: 'stats', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/about', name: 'about', component: { template: '<div/>' } },
+      { path: '/search', name: 'search', component: { template: '<div/>' } },
+      { path: '/about', name: 'about-global', component: { template: '<div/>' } },
+    ],
+  });
+}
+
+function seedStore(datasets: string[] = ['test']) {
+  const store = useVocabularyStore();
+  for (const id of datasets) {
+    store.manifests.set(id, makeManifest(id));
+    store.datasets.set(id, { index: [], getConceptCount: () => 0, getConcepts: () => [] } as any);
+  }
+}
+
+/**
+ * Returns all <a> elements with the custom 'active' class.
+ * This is the class added by the isActive() function in AppSidebar,
+ * distinct from Vue Router's built-in router-link-active.
+ */
+function getActiveHrefs(wrapper: ReturnType<typeof mount>): string[] {
+  return wrapper.findAll('a.active').map(l => l.attributes('href') || '');
+}
+
+describe('AppSidebar — nav highlighting (isActive)', () => {
+  let pinia: ReturnType<typeof createPinia>;
+
+  beforeEach(() => {
+    pinia = createPinia();
+    setActivePinia(pinia);
+  });
+
+  async function mountSidebar(initialPath = '/') {
+    const router = createTestRouter(initialPath);
+    router.push(initialPath);
+    await router.isReady();
+    return mount(AppSidebar, {
+      global: { plugins: [pinia, router], stubs: { NavIcon: true } },
+    });
+  }
+
+  // ── The bug: dataset About should NOT activate global About ─────────
+
+  it('on /dataset/test/about: ONLY dataset about link is active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test/about');
+    const activeHrefs = getActiveHrefs(wrapper);
+    // Dataset about link IS active
+    expect(activeHrefs).toContain('/dataset/test/about');
+    // Global /about link is NOT active (this was the bug)
+    expect(activeHrefs).not.toContain('/about');
+    // Only one active link total
+    expect(activeHrefs).toEqual(['/dataset/test/about']);
+  });
+
+  it('on /dataset/test/about: no link to /about (global) has active class', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test/about');
+    const allLinks = wrapper.findAll('a');
+    const globalAboutLinks = allLinks.filter(l => l.attributes('href') === '/about');
+    // If global about link exists, it must NOT have custom active class
+    for (const link of globalAboutLinks) {
+      expect(link.classes()).not.toContain('active');
+    }
+  });
+
+  // ── Global About page still works ───────────────────────────────────
+
+
+  it('on /about: dataset about links are NOT active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/about');
+    const allLinks = wrapper.findAll('a');
+    const datasetAboutActive = allLinks.filter(
+      l => (l.attributes('href') || '').includes('/dataset/') &&
+           (l.attributes('href') || '').includes('/about') &&
+           l.classes().includes('active')
+    );
+    expect(datasetAboutActive).toEqual([]);
+  });
+
+  // ── Dataset root: dataset Concepts active, global Home not ──────────
+
+  it('on /dataset/test: dataset sub-nav is active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test');
+    // Something should be active (the dataset concepts sub-page)
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('on /dataset/test: global nav links are NOT active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test');
+    const allLinks = wrapper.findAll('a');
+    // Global Search link must NOT be active
+    const searchActive = allLinks.filter(
+      l => l.attributes('href') === '/search' && l.classes().includes('active')
+    );
+    expect(searchActive).toEqual([]);
+  });
+
+  // ── Concept page: dataset Concepts still active ─────────────────────
+
+  it('on /dataset/test/concept/1.2: dataset sub-nav is active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test/concept/1.2');
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs.length).toBeGreaterThanOrEqual(1);
+  });
+
+  // ── Cross-dataset isolation ─────────────────────────────────────────
+
+  it('on /dataset/ds-a/about: ds-b about is NOT active', async () => {
+    seedStore(['ds-a', 'ds-b']);
+    const wrapper = await mountSidebar('/dataset/ds-a/about');
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs).toContain('/dataset/ds-a/about');
+    expect(activeHrefs).not.toContain('/dataset/ds-b/about');
+  });
+
+  // ── Root route ──────────────────────────────────────────────────────
+
+  it('on /: Home link is active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/');
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs).toContain('/');
+  });
+
+  it('on /: search and about are NOT active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/');
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs).not.toContain('/search');
+    expect(activeHrefs).not.toContain('/about');
+  });
+
+  // ── Dataset stats page ──────────────────────────────────────────────
+
+  it('on /dataset/test/stats: stats sub-page is active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test/stats');
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs).toContain('/dataset/test/stats');
+  });
+
+  it('on /dataset/test/stats: about sub-page is NOT active', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test/stats');
+    const activeHrefs = getActiveHrefs(wrapper);
+    expect(activeHrefs).not.toContain('/dataset/test/about');
+  });
+});

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

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { ReferenceResolver } from '../adapters/ReferenceResolver';
+import { UriRouter } from '../adapters/UriRouter';
 import type { Resolution } from '../adapters/types';
 
 type InternalResolution = Extract<Resolution, { type: 'internal' }>;
@@ -10,13 +11,15 @@ function asInternal(r: Resolution | null): InternalResolution | null {
 
 describe('Source reference resolution (citation linking)', () => {
   let resolver: ReferenceResolver;
+  let uriRouter: UriRouter;
 
   beforeEach(() => {
-    resolver = new ReferenceResolver();
+    uriRouter = new UriRouter();
+    resolver = new ReferenceResolver(uriRouter);
     // Register datasets with URI patterns
-    resolver.registerDataset('vim-2012', ['urn:oiml:pub:v:2:2012*']);
-    resolver.registerDataset('viml-2022', ['urn:oiml:pub:v:1:2022*']);
-    resolver.registerDataset('vim-2007', ['urn:oiml:pub:v:2:2007*']);
+    uriRouter.registerDataset('vim-2012', '', '', ['urn:oiml:pub:v:2:2012*']);
+    uriRouter.registerDataset('viml-2022', '', '', ['urn:oiml:pub:v:1:2022*']);
+    uriRouter.registerDataset('vim-2007', '', '', ['urn:oiml:pub:v:2:2007*']);
   });
 
   describe('hasSourceRef', () => {
@@ -132,7 +135,7 @@ describe('Source reference resolution (citation linking)', () => {
 
   describe('ISO source references', () => {
     it('resolves ISO/IEC references when registered', () => {
-      resolver.registerDataset('iso-17000', ['urn:iso:std:iso:iec:17000*']);
+      uriRouter.registerDataset('iso-17000', '', '', ['urn:iso:std:iso:iec:17000*']);
       resolver.registerSourceRef('ISO/IEC 17000:2020', 'iso-17000', 'urn:iso:std:iso:iec:17000');
 
       const result = resolver.resolveCitation('ISO/IEC 17000:2020', '3.1', 'viml-2022');
@@ -171,7 +174,7 @@ describe('Source reference resolution (citation linking)', () => {
     });
 
     it('handles source strings with special characters', () => {
-      resolver.registerDataset('vim-1993', ['urn:oiml:pub:v:2:1993*']);
+      uriRouter.registerDataset('vim-1993', '', '', ['urn:oiml:pub:v:2:1993*']);
       resolver.registerSourceRef('OIML V 2:1993', 'vim-1993', 'urn:oiml:pub:v:2:1993');
       const result = resolver.resolveCitation('OIML V 2:1993', '3.6');
       expect(asInternal(result)?.registerId).toBe('vim-1993');

package/src/__tests__/test-helpers.ts

@@ -2,6 +2,8 @@ import { createPinia, setActivePinia } from 'pinia';
 import { createRouter, createMemoryHistory } from 'vue-router';
 import { LocalizedConcept } from 'glossarist';
 import type { Manifest, ConceptSummary, SearchHit } from '../adapters/types';
+import { ReferenceResolver } from '../adapters/ReferenceResolver';
+import { UriRouter } from '../adapters/UriRouter';
 
 // ── Manifest Factory ──────────────────────────────────────────────────
 
@@ -173,3 +175,21 @@ export function setupPinia() {
   setActivePinia(pinia);
   return pinia;
 }
+
+// ── ReferenceResolver Setup ──────────────────────────────────────────
+
+export interface ResolverPair {
+  uriRouter: UriRouter;
+  resolver: ReferenceResolver;
+}
+
+/**
+ * Create a UriRouter + ReferenceResolver pair for testing.
+ * Use `pair.uriRouter.registerDataset()` to register URI patterns,
+ * then use `pair.resolver` for reference resolution.
+ */
+export function createResolverPair(): ResolverPair {
+  const uriRouter = new UriRouter();
+  const resolver = new ReferenceResolver(uriRouter);
+  return { uriRouter, resolver };
+}

package/src/__tests__/uri-router.test.ts

@@ -1,12 +1,16 @@
 import { describe, it, expect } from 'vitest';
 import { UriRouter } from '../adapters/UriRouter';
 
-const MOCK_MANIFEST = { uriBase: 'https://glossarist.org' } as any;
-
 describe('UriRouter', () => {
+  const URI_BASE = 'https://glossarist.org';
+
+  function register(router: UriRouter, registerId: string, baseUrl: string = `/data/${registerId}`) {
+    router.registerDataset(registerId, baseUrl, URI_BASE, [`${URI_BASE}/${registerId}/*`]);
+  }
+
   it('resolves URIs for registered datasets', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
+    register(router, 'iev');
 
     const resolved = router.resolveUri('https://glossarist.org/iev/concept/103-01-02');
     expect(resolved).toEqual({ registerId: 'iev', conceptId: '103-01-02' });
@@ -14,7 +18,7 @@ describe('UriRouter', () => {
 
   it('resolves URIs with multi-part concept IDs', () => {
     const router = new UriRouter();
-    router.registerDataset('isotc204', '/data/isotc204', MOCK_MANIFEST);
+    register(router, 'isotc204');
 
     const resolved = router.resolveUri('https://glossarist.org/isotc204/concept/3.1.1.1');
     expect(resolved).toEqual({ registerId: 'isotc204', conceptId: '3.1.1.1' });
@@ -22,43 +26,66 @@ describe('UriRouter', () => {
 
   it('returns null for unknown register', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
+    register(router, 'iev');
 
     expect(router.resolveUri('https://glossarist.org/unknown/concept/123')).toBeNull();
   });
 
   it('returns null for non-matching URI pattern', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
+    register(router, 'iev');
 
     expect(router.resolveUri('https://example.com/other')).toBeNull();
   });
 
   it('builds URIs from register and concept ID', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
+    register(router, 'iev');
     expect(router.buildUri('iev', '103-01-02')).toBe('https://glossarist.org/iev/concept/103-01-02');
   });
 
   it('lists all registered IDs', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
-    router.registerDataset('isotc211', '/data/isotc211', MOCK_MANIFEST);
+    register(router, 'iev');
+    register(router, 'isotc211');
 
     expect(router.getRegisteredIds()).toEqual(['iev', 'isotc211']);
   });
 
   it('resolves across multiple registers', () => {
     const router = new UriRouter();
-    router.registerDataset('iev', '/data/iev', MOCK_MANIFEST);
-    router.registerDataset('isotc211', '/data/isotc211', MOCK_MANIFEST);
-    router.registerDataset('isotc204', '/data/isotc204', MOCK_MANIFEST);
+    register(router, 'iev');
+    register(router, 'isotc211');
+    register(router, 'isotc204');
 
     expect(router.resolveUri('https://glossarist.org/iev/concept/102-01-01')?.registerId).toBe('iev');
     expect(router.resolveUri('https://glossarist.org/isotc211/concept/10')?.registerId).toBe('isotc211');
     expect(router.resolveUri('https://glossarist.org/isotc204/concept/3.1.1.1')?.registerId).toBe('isotc204');
   });
 
+  it('resolves URN patterns with wildcard', () => {
+    const router = new UriRouter();
+    router.registerDataset('iso-10303', '', '', ['urn:iso:std:iso:10303:*']);
+
+    const resolved = router.resolveUri('urn:iso:std:iso:10303:3.1.1.1');
+    expect(resolved).toEqual({ registerId: 'iso-10303', conceptId: '3.1.1.1' });
+  });
+
+  it('resolves URN prefix to registerId', () => {
+    const router = new UriRouter();
+    router.registerDataset('iso-10303', '', '', ['urn:iso:std:iso:10303:*']);
+
+    expect(router.resolveUrn('urn:iso:std:iso:10303')).toBe('iso-10303');
+    expect(router.resolveUrn('urn:unknown:prefix')).toBeNull();
+  });
+
+  it('returns uriBase for registered dataset', () => {
+    const router = new UriRouter();
+    register(router, 'iev');
+    expect(router.getUriBase('iev')).toBe(URI_BASE);
+    expect(router.getUriBase('unknown')).toBe('');
+  });
+
   describe('parseUri (static)', () => {
     it('extracts register and concept from any glossarist URI', () => {
       expect(UriRouter.parseUri('https://glossarist.org/iev/concept/103-01-02')).toEqual({

package/src/adapters/DatasetAdapter.ts

@@ -44,6 +44,7 @@ export class DatasetAdapter {
   private conceptCache = new Map<string, Concept>();
   private static MAX_CACHE = 100;
   private summaryMap = new Map<string, ConceptSummary>();
+  private designationMap = new Map<string, string>();
   private loadedChunks = new Set<number>();
   private indexMeta: { conceptCount: number; chunkSize: number; chunks: { file: string; count: number }[] } | null = null;
 
@@ -127,11 +128,17 @@ export class DatasetAdapter {
   private buildSummaryIndex() {
     this.summaryMap.clear();
     this.positionIndex.clear();
+    this.designationMap.clear();
     for (let i = 0; i < this.index!.concepts.length; i++) {
       const entry = this.index!.concepts[i];
       if (entry) {
         this.summaryMap.set(entry.id, entry);
         this.positionIndex.set(entry.id, i);
+        for (const term of Object.values(entry.designations)) {
+          if (term && !this.designationMap.has(term.toLowerCase())) {
+            this.designationMap.set(term.toLowerCase(), entry.id);
+          }
+        }
       }
     }
   }
@@ -263,6 +270,11 @@ export class DatasetAdapter {
     return this.summaryMap.get(conceptId);
   }
 
+  /** Look up a concept ID by its designation string (case-insensitive). */
+  lookupByDesignation(designation: string): string | undefined {
+    return this.designationMap.get(designation.toLowerCase());
+  }
+
   getConcepts(): (ConceptSummary | undefined)[] {
     return this.index?.concepts ?? [];
   }

package/src/adapters/GraphDataSource.ts

@@ -1,7 +1,7 @@
 import type { GraphEdge, GraphNode, SectionNode } from './types';
 import type { Concept, RelatedConcept } from 'glossarist';
 import type { DatasetAdapter } from './DatasetAdapter';
-import { ReferenceResolver } from './ReferenceResolver';
+import { UriRouter } from './UriRouter';
 import { slugify } from '../utils/slugify';
 
 interface DomainNodeJson {
@@ -80,7 +80,7 @@ export class GraphDataSource {
     for (const rc of concept.relatedConcepts) {
       const target = resolveRefTarget(rc, this.uriBase, this.registerId, this.urnMap);
       if (target && target !== sourceUri) {
-        const parsed = ReferenceResolver.parseUri(target);
+        const parsed = UriRouter.parseUri(target);
         edges.push({
           source: sourceUri,
           target,
@@ -97,7 +97,7 @@ export class GraphDataSource {
       for (const rc of lc.related) {
         const target = resolveRefTarget(rc, this.uriBase, this.registerId, this.urnMap);
         if (target && target !== sourceUri) {
-          const parsed = ReferenceResolver.parseUri(target);
+          const parsed = UriRouter.parseUri(target);
           edges.push({
             source: sourceUri,
             target,

package/src/adapters/ReferenceResolver.ts

@@ -1,46 +1,45 @@
 import type { Resolution } from './types';
 import type { RoutingEntry } from '../config/types';
+import { UriRouter } from './UriRouter';
 
-interface DatasetEntry {
-  id: string;
-  uriPatterns: string[];
-}
+// ── Citation classification ────────────────────────────────────────────────
 
-function extractConceptId(uri: string, pattern: string): string | null {
-  if (!pattern.endsWith('*')) return null;
-  const base = pattern.slice(0, -1);
-  if (!uri.startsWith(base)) return null;
-  const remainder = uri.slice(base.length);
+export type CitationClassification =
+  | 'internal-citation'
+  | 'self-contained-citation'
+  | 'external-citation'
+  | 'unresolved-citation';
 
-  if (uri.startsWith('https://') || uri.startsWith('http://')) {
-    const match = remainder.match(/^\/?concept\/([^/?#]+)/);
-    return match ? match[1] : null;
-  }
-  if (uri.startsWith('urn:')) {
-    return remainder || null;
-  }
-  return null;
+export interface CiteResolution {
+  classification: CitationClassification;
+  resolved: { registerId: string; conceptId: string } | null;
 }
 
-function matchUriPattern(uri: string, pattern: string): boolean {
-  if (!pattern.endsWith('*')) return uri === pattern;
-  return uri.startsWith(pattern.slice(0, -1));
+/**
+ * Lightweight citation shape used for classification.
+ * Uses snake_case to match glossarist's Citation model conventions.
+ */
+interface CitationInput {
+  ref?: { source?: string | null; id?: string | null; version?: string | null } | null;
+  locality?: { type?: string | null; reference_from?: string | null; reference_to?: string | null; referenceFrom?: string | null; referenceTo?: string | null } | null;
+  link?: string | null;
 }
 
+// ── ReferenceResolver ──────────────────────────────────────────────────────
+
+/**
+ * Resolves references (citations, source refs, URNs) to concepts.
+ *
+ * Delegates URI pattern matching to UriRouter (the single authority for URI routing).
+ * Adds its own concerns on top: source-ref mapping, routing table, citation classification.
+ */
 export class ReferenceResolver {
-  private datasets: DatasetEntry[] = [];
   private routing: RoutingEntry[] = [];
   private sourceRefs = new Map<string, { datasetId: string; uriPrefix: string }>();
+  private readonly uriRouter: UriRouter;
 
-  private static readonly URI_REGISTER_RE = /\/([^/]+)\/concept\/([^/]+)$/;
-
-  static parseUri(uri: string): { registerId: string; conceptId: string } | null {
-    const m = uri.match(ReferenceResolver.URI_REGISTER_RE);
-    return m ? { registerId: m[1], conceptId: m[2] } : null;
-  }
-
-  registerDataset(id: string, uriPatterns: string[]): void {
-    this.datasets.push({ id, uriPatterns });
+  constructor(uriRouter: UriRouter) {
+    this.uriRouter = uriRouter;
   }
 
   registerSourceRef(sourceRef: string, datasetId: string, uriPrefix: string): void {
@@ -56,26 +55,20 @@ export class ReferenceResolver {
   }
 
   resolveReference(uri: string, sourceDatasetId?: string): Resolution {
-    // Step 1: Check provided datasets
-    for (const ds of this.datasets) {
-      for (const pattern of ds.uriPatterns) {
-        if (matchUriPattern(uri, pattern)) {
-          const conceptId = extractConceptId(uri, pattern);
-          if (conceptId) {
-            return {
-              type: 'internal',
-              registerId: ds.id,
-              conceptId,
-              crossDataset: sourceDatasetId != null && sourceDatasetId !== ds.id,
-            };
-          }
-        }
-      }
+    // Step 1: Check registered datasets via UriRouter
+    const resolved = this.uriRouter.resolveUri(uri);
+    if (resolved) {
+      return {
+        type: 'internal',
+        registerId: resolved.registerId,
+        conceptId: resolved.conceptId,
+        crossDataset: sourceDatasetId != null && sourceDatasetId !== resolved.registerId,
+      };
     }
 
     // Step 2: Check routing table
     for (const entry of this.routing) {
-      if (matchUriPattern(uri, entry.uri)) {
+      if (this.matchesRoutingPattern(uri, entry.uri)) {
         if (entry.type === 'site') {
           return {
             type: 'site',
@@ -86,7 +79,7 @@ export class ReferenceResolver {
         }
         if (entry.type === 'url') {
           const template = entry.url!;
-          const conceptId = this.extractConceptIdFromRouting(uri, entry.uri);
+          const conceptId = this.extractConceptIdFromRouting(uri);
           const url = template.includes('{conceptId}') && conceptId
             ? template.replace('{conceptId}', conceptId)
             : template;
@@ -122,6 +115,32 @@ export class ReferenceResolver {
     return null;
   }
 
+  /**
+   * Classify a citation and resolve it to a concept if possible.
+   * Single source of truth for citation resolution — both classification
+   * and navigation target come from this one method.
+   */
+  resolveCite(citation: CitationInput | null | undefined, sourceDatasetId?: string): CiteResolution {
+    if (!citation?.ref?.source) {
+      return { classification: 'unresolved-citation', resolved: null };
+    }
+
+    const referenceFrom = citation.locality?.reference_from ?? citation.locality?.referenceFrom ?? '';
+    const resolution = this.resolveCitation(citation.ref.source, referenceFrom, sourceDatasetId);
+    if (resolution?.type === 'internal') {
+      return {
+        classification: 'internal-citation',
+        resolved: { registerId: resolution.registerId, conceptId: resolution.conceptId },
+      };
+    }
+
+    if (citation.link) {
+      return { classification: 'self-contained-citation', resolved: null };
+    }
+
+    return { classification: 'external-citation', resolved: null };
+  }
+
   resolveRelatedRef(ref: { source: string | null; id: string | null } | null, sourceDatasetId?: string): { registerId: string; conceptId: string } | null {
     if (!ref?.source || !ref?.id) return null;
     const uri = `${ref.source}/${ref.id}`;
@@ -139,14 +158,25 @@ export class ReferenceResolver {
     return null;
   }
 
-  private extractConceptIdFromRouting(uri: string, pattern: string): string | null {
-    for (const ds of this.datasets) {
-      for (const dsPattern of ds.uriPatterns) {
-        if (matchUriPattern(uri, dsPattern)) {
-          return extractConceptId(uri, dsPattern);
-        }
-      }
+  // ── Routing table helpers ────────────────────────────────────────────────
+
+  private matchesRoutingPattern(uri: string, pattern: string): boolean {
+    if (!pattern.endsWith('*')) return uri === pattern;
+    return uri.startsWith(pattern.slice(0, -1));
+  }
+
+  private extractConceptIdFromRouting(uri: string): string | null {
+    const resolved = this.uriRouter.resolveUri(uri);
+    if (resolved) return resolved.conceptId;
+    // Fallback: extract from URI structure
+    // HTTP: /concept/{id}
+    const httpMatch = uri.match(/\/concept\/([^/?#]+)/);
+    if (httpMatch) return httpMatch[1];
+    // URN: last colon-separated segment
+    if (uri.startsWith('urn:')) {
+      const parts = uri.split(':');
+      return parts.length > 0 ? parts[parts.length - 1] : null;
     }
-    return extractConceptId(uri, pattern);
+    return null;
   }
 }