@glossarist/concept-browser 0.7.31 → 0.7.33

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

@@ -0,0 +1,128 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { getFactory, resetFactory } from '../adapters/factory';
+import type { Resolution } from '../adapters/types';
+
+type InternalResolution = Extract<Resolution, { type: 'internal' }>;
+
+function asInternal(r: Resolution | null): InternalResolution | null {
+  return r?.type === 'internal' ? (r as InternalResolution) : null;
+}
+
+describe('AdapterFactory — bibliography resolution from registry', () => {
+  beforeEach(() => {
+    resetFactory();
+    vi.restoreAllMocks();
+  });
+
+  it('registers bibliography from registry ref/refAliases', async () => {
+    const factory = getFactory();
+    const mockFetch = vi.fn((url: string) => {
+      if (url.endsWith('datasets.json')) {
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve([
+            {
+              id: 'vim-2012',
+              manifestUrl: '/data/vim-2012/manifest.json',
+              summary: {
+                title: 'VIM 2012',
+                description: 'Vocabulary of metrology',
+                conceptCount: 144,
+                languages: ['eng', 'fra'],
+                owner: 'OIML',
+                tags: [],
+              },
+              datasetUri: 'urn:oiml:pub:v:2:2012',
+              uriBase: 'https://glossarist.org',
+              uriAliases: ['urn:oiml:pub:v:2:2012*'],
+              ref: 'OIML V 2-200:2012',
+              refAliases: ['VIM'],
+            },
+          ]),
+        });
+      }
+      return Promise.resolve({ ok: false, status: 404 } as Response);
+    });
+    vi.stubGlobal('fetch', mockFetch);
+
+    await factory.discoverDatasets('/datasets.json');
+
+    // No source-refs.json fetch — bibliography comes from registry config
+    expect(mockFetch).not.toHaveBeenCalledWith(expect.stringContaining('source-refs'));
+
+    // ref resolves via bibliography config
+    const result = factory.resolveCitation('OIML V 2-200:2012', '2.2', 'viml-2022');
+    expect(result).toEqual({
+      type: 'internal',
+      registerId: 'vim-2012',
+      conceptId: '2.2',
+      crossDataset: true,
+    });
+
+    // refAlias resolves too
+    const alias = factory.resolveCitation('VIM', '2.2', 'viml-2022');
+    expect(asInternal(alias)?.registerId).toBe('vim-2012');
+
+    // URN resolves directly via URI pattern matching (no bibliography entry needed)
+    const urn = factory.resolveCitation('urn:oiml:pub:v:2:2012', '2.2', 'viml-2022');
+    expect(asInternal(urn)?.registerId).toBe('vim-2012');
+  });
+
+  it('resolves without ref/refAliases when only datasetUri is present', async () => {
+    const factory = getFactory();
+    const mockFetch = vi.fn((url: string) => {
+      if (url.endsWith('datasets.json')) {
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve([
+            {
+              id: 'ds1',
+              manifestUrl: '/data/ds1/manifest.json',
+              summary: {
+                title: 'DS1',
+                description: 'Test',
+                conceptCount: 10,
+                languages: ['eng'],
+                owner: 'Test',
+                tags: [],
+              },
+            },
+          ]),
+        });
+      }
+      return Promise.resolve({ ok: false, status: 404 } as Response);
+    });
+    vi.stubGlobal('fetch', mockFetch);
+
+    const adapters = await factory.discoverDatasets('/datasets.json');
+    expect(adapters).toHaveLength(1);
+  });
+
+  it('skips registry entries without datasetUri for bibliography', async () => {
+    const factory = getFactory();
+    const mockFetch = vi.fn((url: string) => {
+      if (url.endsWith('datasets.json')) {
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve([
+            {
+              id: 'ds1',
+              manifestUrl: '/data/ds1/manifest.json',
+              summary: { title: 'DS1', description: 'Test', conceptCount: 10, languages: ['eng'], owner: 'Test', tags: [] },
+              ref: 'Some Ref',
+              // No datasetUri — bibliography entry skipped
+            },
+          ]),
+        });
+      }
+      return Promise.resolve({ ok: false, status: 404 } as Response);
+    });
+    vi.stubGlobal('fetch', mockFetch);
+
+    await factory.discoverDatasets('/datasets.json');
+
+    // ref without URN can't resolve — no datasetUri to route to
+    const result = factory.resolveCitation('Some Ref', '1.1');
+    expect(result).toBeNull();
+  });
+});

package/src/__tests__/slugify.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { slugify } from '../utils/slugify';
+
+describe('slugify', () => {
+  it('lowercases text', () => {
+    expect(slugify('Hello World')).toBe('hello-world');
+  });
+
+  it('strips slashes and joins surrounding text', () => {
+    expect(slugify('foo bar/baz')).toBe('foo-barbaz');
+  });
+
+  it('strips non-word characters', () => {
+    expect(slugify('géométrie (2D)')).toBe('gomtrie-2d');
+  });
+
+  it('collapses multiple spaces into single hyphen', () => {
+    expect(slugify('a   b')).toBe('a-b');
+  });
+
+  it('handles empty string', () => {
+    expect(slugify('')).toBe('');
+  });
+
+  it('preserves hyphens in input', () => {
+    expect(slugify('iso-19107')).toBe('iso-19107');
+  });
+});

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

@@ -0,0 +1,191 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ReferenceResolver } from '../adapters/ReferenceResolver';
+import type { Resolution } from '../adapters/types';
+
+type InternalResolution = Extract<Resolution, { type: 'internal' }>;
+
+function asInternal(r: Resolution | null): InternalResolution | null {
+  return r?.type === 'internal' ? (r as InternalResolution) : null;
+}
+
+describe('Source reference resolution (citation linking)', () => {
+  let resolver: ReferenceResolver;
+
+  beforeEach(() => {
+    resolver = new ReferenceResolver();
+    // 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*']);
+  });
+
+  describe('hasSourceRef', () => {
+    it('returns true for registered source ref', () => {
+      resolver.registerSourceRef('VIM', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      expect(resolver.hasSourceRef('VIM')).toBe(true);
+    });
+
+    it('returns false for unregistered source ref', () => {
+      expect(resolver.hasSourceRef('Unknown')).toBe(false);
+    });
+  });
+
+  describe('registerSourceRef', () => {
+    it('resolves citation when source ref matches exactly', () => {
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      const result = resolver.resolveCitation('OIML V 2-200:2012', '2.2', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '2.2',
+        crossDataset: true,
+      });
+    });
+
+    it('resolves citation using variant source string', () => {
+      // Manifest has "OIML V 2-200:2012" but concepts use "OIML V2-200:2012"
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      resolver.registerSourceRef('OIML V2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+
+      const result = resolver.resolveCitation('OIML V2-200:2012', '2.2', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '2.2',
+        crossDataset: true,
+      });
+    });
+
+    it('resolves citation using URN as source', () => {
+      resolver.registerSourceRef('urn:oiml:pub:v:2:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      const result = resolver.resolveCitation('urn:oiml:pub:v:2:2012', '2.2', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '2.2',
+        crossDataset: true,
+      });
+    });
+
+    it('resolves citation using ref alias (e.g. "VIM")', () => {
+      resolver.registerSourceRef('VIM', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      const result = resolver.resolveCitation('VIM', '2.2', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '2.2',
+        crossDataset: true,
+      });
+    });
+
+    it('returns null when source ref is not registered', () => {
+      const result = resolver.resolveCitation('Unknown Source', '2.2', 'viml-2022');
+      expect(result).toBeNull();
+    });
+
+    it('returns null when source ref matches but concept does not exist in dataset', () => {
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      // The resolver can only check if the dataset exists, not if the concept exists
+      // It will still return internal if the dataset is registered
+      const result = resolver.resolveCitation('OIML V 2-200:2012', '99.99', 'viml-2022');
+      expect(result?.type).toBe('internal');
+    });
+
+    it('handles same-dataset citation (crossDataset=false)', () => {
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      const result = resolver.resolveCitation('OIML V 2-200:2012', '2.2', 'vim-2012');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '2.2',
+        crossDataset: false,
+      });
+    });
+  });
+
+  describe('resolveCitation fallback to URN', () => {
+    it('resolves URN-based source without registerSourceRef', () => {
+      // When source starts with "urn:", tryResolveCitationUri handles it
+      const result = resolver.resolveCitation('urn:oiml:pub:v:2:2012', '2.2', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '2.2',
+        crossDataset: true,
+      });
+    });
+  });
+
+  describe('multiple source strings for same dataset', () => {
+    it('registers multiple source refs pointing to the same dataset', () => {
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      resolver.registerSourceRef('OIML V2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      resolver.registerSourceRef('VIM', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      resolver.registerSourceRef('ISO Guide 99:2007', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+
+      expect(asInternal(resolver.resolveCitation('OIML V 2-200:2012', '2.2'))?.registerId).toBe('vim-2012');
+      expect(asInternal(resolver.resolveCitation('OIML V2-200:2012', '2.2'))?.registerId).toBe('vim-2012');
+      expect(asInternal(resolver.resolveCitation('VIM', '2.2'))?.registerId).toBe('vim-2012');
+      expect(asInternal(resolver.resolveCitation('ISO Guide 99:2007', '2.2'))?.registerId).toBe('vim-2012');
+    });
+  });
+
+  describe('ISO source references', () => {
+    it('resolves ISO/IEC references when registered', () => {
+      resolver.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');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'iso-17000',
+        conceptId: '3.1',
+        crossDataset: true,
+      });
+    });
+
+    it('returns null for unresolvable ISO references', () => {
+      // ISO dataset not loaded — no registerSourceRef or dataset pattern match
+      const result = resolver.resolveCitation('ISO/IEC 17000:2020', '3.1', 'viml-2022');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('returns internal with empty conceptId when referenceFrom is empty', () => {
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      const result = resolver.resolveCitation('OIML V 2-200:2012', '');
+      // Resolver still resolves but with empty conceptId — UI handles this
+      expect(result?.type).toBe('internal');
+    });
+
+    it('handles concept IDs with dots', () => {
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      const result = resolver.resolveCitation('OIML V 2-200:2012', '5.12.3', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '5.12.3',
+        crossDataset: true,
+      });
+    });
+
+    it('handles source strings with special characters', () => {
+      resolver.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');
+    });
+
+    it('does not confuse similar source strings', () => {
+      resolver.registerSourceRef('OIML V 2-200:2007', 'vim-2007', 'urn:oiml:pub:v:2:2007');
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+
+      const result2007 = resolver.resolveCitation('OIML V 2-200:2007', '2.2');
+      const result2012 = resolver.resolveCitation('OIML V 2-200:2012', '2.2');
+
+      expect(asInternal(result2007)?.registerId).toBe('vim-2007');
+      expect(asInternal(result2012)?.registerId).toBe('vim-2012');
+    });
+  });
+});

package/src/adapters/DatasetAdapter.ts

@@ -9,15 +9,47 @@ import type {
   SectionNode,
   DatasetSummary,
 } from './types';
-import type { Concept, LocalizedConcept, Designation } from 'glossarist';
+import type { Concept, LocalizedConcept, Designation, RelatedConcept } from 'glossarist';
 import { conceptFromJson, conceptUri } from './model-bridge';
 import { UriRouter } from './UriRouter';
+import { slugify } from '../utils/slugify';
 
-function slugify(text: string): string {
-  return text.toLowerCase().replace(/[^\w\s-]/g, '').replace(/[\s/]+/g, '-');
+// ── Wire-format types for JSON responses ────────────────────────────────────
+
+interface IndexJson {
+  registerId: string;
+  schemaVersion: string;
+  conceptCount: number;
+  chunkSize: number;
+  chunks: { file: string; count: number }[];
+  concepts: IndexConceptJson[];
+}
+
+interface IndexConceptJson {
+  id: string;
+  designations?: Record<string, string>;
+  eng?: string;
+  status: string;
+  groups?: string[];
+}
+
+interface DomainNodeJson {
+  uri?: string;
+  id?: string;
+  registerId?: string;
+  label?: string;
+  names?: Record<string, string>;
+  conceptCount?: number;
+  children?: DomainNodeJson[];
+}
+
+interface SectionJson {
+  id: string;
+  names?: Record<string, string>;
+  children?: SectionJson[];
 }
 
-function resolveRefTarget(rc: any, uriBase: string, registerId: string, urnMap?: ReadonlyMap<string, string>): string {
+function resolveRefTarget(rc: RelatedConcept, uriBase: string, registerId: string, urnMap?: ReadonlyMap<string, string>): string {
   if (!rc.ref) return '';
   const ref = rc.ref;
   if (ref.id) {
@@ -99,13 +131,13 @@ export class DatasetAdapter {
     const data = await resp.json();
 
     // Handle both old format (with eng/status fields) and new format (with designations map)
-    this.index = this.normalizeIndex(data);
+    this.index = this.normalizeIndex(data as IndexJson);
     this.buildSummaryIndex();
     return this.index;
   }
 
-  private normalizeIndex(data: any): ConceptIndex {
-    const concepts: ConceptSummary[] = (data.concepts || []).map((c: any) => ({
+  private normalizeIndex(data: IndexJson): ConceptIndex {
+    const concepts: ConceptSummary[] = (data.concepts || []).map((c) => ({
       id: c.id,
       designations: c.designations || {},
       eng: c.eng || c.designations?.eng || Object.values(c.designations || {})[0] || '',
@@ -144,7 +176,7 @@ export class DatasetAdapter {
       const resp = await fetch(`${this.baseUrl}/index.json`);
       if (!resp.ok) throw new Error(`Failed to load index for ${this.registerId}`);
       const data = await resp.json();
-      this.index = this.normalizeIndex(data);
+      this.index = this.normalizeIndex(data as IndexJson);
       this.buildSummaryIndex();
       return this.index;
     }
@@ -412,34 +444,34 @@ export class DatasetAdapter {
     const resp = await fetch(`${this.baseUrl}/domain-nodes.json`);
     if (!resp.ok) return [];
     const data = await resp.json();
-    return (data.domainNodes || []).map((dn: any) => this.mapDomainNode(dn));
+    return (data.domainNodes || []).map((dn: DomainNodeJson) => this.mapDomainNode(dn));
   }
 
-  private mapDomainNode(dn: any): GraphNode {
+  private mapDomainNode(dn: DomainNodeJson): GraphNode {
     const node: GraphNode = {
-      uri: dn.uri,
-      register: dn.registerId,
+      uri: dn.uri ?? '',
+      register: dn.registerId ?? '',
       conceptId: dn.uri?.split('/domain/')[1] || dn.id || '',
-      designations: dn.names || { eng: dn.label },
+      designations: dn.names || (dn.label ? { eng: dn.label } : {}),
       status: 'domain',
       loaded: true,
       nodeType: 'domain' as const,
       conceptCount: dn.conceptCount || 0,
     };
     if (dn.children && dn.children.length > 0) {
-      node.children = dn.children.map((c: any) => this.mapSectionNode(c));
+      node.children = dn.children.map((c) => this.mapSectionNode(c));
     }
     return node;
   }
 
-  private mapSectionNode(dn: any): SectionNode {
+  private mapSectionNode(dn: DomainNodeJson): SectionNode {
     const node: SectionNode = {
-      id: dn.id,
-      names: dn.names || { eng: dn.label },
+      id: dn.id ?? '',
+      names: dn.names || (dn.label ? { eng: dn.label } : {}),
       conceptCount: dn.conceptCount || 0,
     };
     if (dn.children && dn.children.length > 0) {
-      node.children = dn.children.map((c: any) => this.mapSectionNode(c));
+      node.children = dn.children.map((c) => this.mapSectionNode(c));
     }
     return node;
   }
@@ -450,7 +482,7 @@ export class DatasetAdapter {
     return nodes.map(s => this.mapManifestSection(s));
   }
 
-  private mapManifestSection(s: { id: string; names: Record<string, string>; children?: any[] }): SectionNode {
+  private mapManifestSection(s: SectionJson): SectionNode {
     const node: SectionNode = { id: s.id, names: s.names || {}, conceptCount: 0 };
     if (s.children && s.children.length > 0) {
       node.children = s.children.map(c => this.mapManifestSection(c));

package/src/adapters/ReferenceResolver.ts

@@ -40,6 +40,10 @@ export class ReferenceResolver {
     this.sourceRefs.set(sourceRef, { datasetId, uriPrefix });
   }
 
+  hasSourceRef(sourceRef: string): boolean {
+    return this.sourceRefs.has(sourceRef);
+  }
+
   loadRouting(entries: RoutingEntry[]): void {
     this.routing = entries;
   }
@@ -90,6 +94,7 @@ export class ReferenceResolver {
   resolveCitation(source: string, referenceFrom: string, sourceDatasetId?: string): Resolution | null {
     const entry = this.sourceRefs.get(source);
     if (!entry) {
+      // URN-based source strings resolve directly via dataset URI patterns
       if (!source.startsWith('urn:')) return null;
       return this.tryResolveCitationUri(source, referenceFrom, sourceDatasetId);
     }

package/src/adapters/factory.ts

@@ -46,18 +46,25 @@ export class AdapterFactory {
       await Promise.all(needManifest.map(a => a.loadManifest().catch(() => {})));
     }
 
-    // Register all datasets' URI patterns eagerly so cross-dataset refs resolve
     for (const adapter of adapters) {
       if (adapter.manifest) {
-        this.registerUriPatterns(adapter.registerId, adapter.manifest);
+        this.registerDataset(adapter.registerId, adapter.manifest);
       }
     }
-    for (const adapter of this.adapters.values()) {
-      adapter.setUrnMap(this.urnMap);
+
+    // Register bibliography from registry config (ref/refAliases → URN)
+    // This is the single source of truth — no separate source-refs file needed.
+    for (const reg of registry) {
+      if (!reg.datasetUri) continue;
+      if (reg.ref) {
+        this.resolver.registerSourceRef(reg.ref, reg.id, reg.datasetUri);
+      }
+      for (const alias of reg.refAliases ?? []) {
+        this.resolver.registerSourceRef(alias, reg.id, reg.datasetUri);
+      }
     }
 
     return adapters;
-
   }
 
   getAdapter(registerId: string): DatasetAdapter | undefined {
@@ -68,8 +75,9 @@ export class AdapterFactory {
     return [...this.adapters.values()];
   }
 
+  private registerDataset(registerId: string, manifest: Manifest): void {
+    this.router.registerDataset(registerId, `${import.meta.env.BASE_URL}data/${registerId}`, manifest);
 
-  private registerUriPatterns(registerId: string, manifest: Manifest): void {
     const uriPatterns = [
       manifest.datasetUri,
       ...(manifest.uriAliases ?? []),
@@ -77,18 +85,15 @@ export class AdapterFactory {
     ].filter(Boolean) as string[];
     this.resolver.registerDataset(registerId, uriPatterns);
 
-    if (manifest.ref) {
-      this.resolver.registerSourceRef(manifest.ref, registerId, manifest.datasetUri);
-    }
-    for (const alias of manifest.refAliases ?? []) {
-      this.resolver.registerSourceRef(alias, registerId, manifest.datasetUri);
-    }
-
     if (manifest.datasetUri) this.urnMap.set(manifest.datasetUri, registerId);
     for (const alias of manifest.uriAliases ?? []) {
       const base = alias.endsWith('*') ? alias.slice(0, -1) : alias;
       if (base.startsWith('urn:')) this.urnMap.set(base, registerId);
     }
+
+    for (const adapter of this.adapters.values()) {
+      adapter.setUrnMap(this.urnMap);
+    }
   }
 
   async loadDataset(registerId: string): Promise<DatasetAdapter> {
@@ -98,33 +103,7 @@ export class AdapterFactory {
     const manifest = await adapter.loadManifest();
     await adapter.loadIndex();
 
-    this.router.registerDataset(registerId, `${import.meta.env.BASE_URL}data/${registerId}`, manifest);
-
-    const uriPatterns = [
-      manifest.datasetUri,
-      ...(manifest.uriAliases ?? []),
-      manifest.uriBase ? `${manifest.uriBase}/${registerId}/*` : undefined,
-    ].filter(Boolean) as string[];
-    this.resolver.registerDataset(registerId, uriPatterns);
-
-    if (manifest.ref) {
-      this.resolver.registerSourceRef(manifest.ref, registerId, manifest.datasetUri);
-    }
-    for (const alias of manifest.refAliases ?? []) {
-      this.resolver.registerSourceRef(alias, registerId, manifest.datasetUri);
-    }
-
-    // Build URN→datasetId map from manifest
-    if (manifest.datasetUri) this.urnMap.set(manifest.datasetUri, registerId);
-    for (const alias of manifest.uriAliases ?? []) {
-      const base = alias.endsWith('*') ? alias.slice(0, -1) : alias;
-      if (base.startsWith('urn:')) this.urnMap.set(base, registerId);
-    }
-
-    // Distribute the updated URN map to all loaded adapters
-    for (const adapter of this.adapters.values()) {
-      adapter.setUrnMap(this.urnMap);
-    }
+    this.registerDataset(registerId, manifest);
 
     return adapter;
   }
@@ -137,6 +116,23 @@ export class AdapterFactory {
     return this.resolver.resolveReference(uri, sourceDatasetId);
   }
 
+  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}`;
+    const resolution = this.resolve(uri, sourceDatasetId);
+    if (resolution.type === 'internal') {
+      return { registerId: resolution.registerId, conceptId: resolution.conceptId.replace(/^\//, '') };
+    }
+    if (ref.source.startsWith('urn:')) {
+      const directUri = ref.source + ref.id;
+      const directRes = this.resolve(directUri, sourceDatasetId);
+      if (directRes.type === 'internal') {
+        return { registerId: directRes.registerId, conceptId: directRes.conceptId.replace(/^\//, '') };
+      }
+    }
+    return null;
+  }
+
   resolveCitation(source: string, referenceFrom: string, sourceDatasetId?: string): Resolution | null {
     return this.resolver.resolveCitation(source, referenceFrom, sourceDatasetId);
   }