@glossarist/concept-browser 0.7.32 → 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

@@ -19,6 +19,17 @@ describe('Source reference resolution (citation linking)', () => {
     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');

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,21 +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);
-    }
 
-    // Load source-refs index for citation resolution
-    await this.loadSourceRefs();
+    // 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 {
@@ -71,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 ?? []),
@@ -80,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> {
@@ -101,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;
   }
@@ -140,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);
   }
@@ -157,21 +150,6 @@ export class AdapterFactory {
     this.crossRefIndex = this.crossRefIndex || {};
     return this.crossRefIndex;
   }
-
-  async loadSourceRefs(): Promise<void> {
-    try {
-      const resp = await fetch(`${import.meta.env.BASE_URL}data/source-refs.json`);
-      if (!resp.ok) return;
-      const refs: Record<string, string> = await resp.json();
-      for (const [source, datasetId] of Object.entries(refs)) {
-        const adapter = this.adapters.get(datasetId);
-        if (!adapter?.manifest) continue;
-        this.resolver.registerSourceRef(source, datasetId, adapter.manifest.datasetUri);
-      }
-    } catch {
-      // source-refs.json is optional
-    }
-  }
 }
 
 let _instance: AdapterFactory | null = null;

package/src/adapters/model-bridge.ts

@@ -179,10 +179,10 @@ export function getAnnotations(lc: LocalizedConcept): DetailedDefinition[] {
 }
 
 // Designation relationship targets: RelatedConcept.target (string)
-const designationTargets = new WeakMap<RelatedConcept, string>();
+const designationTargets = new WeakMap<object, string>();
 
-export function getDesignationTarget(rc: RelatedConcept): string | null {
-  return designationTargets.get(rc) ?? null;
+export function getDesignationTarget(rc: { type?: string | null; content?: string | null; target?: string | null; ref?: any }): string | null {
+  return designationTargets.get(rc) ?? rc.target ?? null;
 }
 
 // ConceptRef text: human-readable label alongside source/id
@@ -213,23 +213,28 @@ function attachAnnotations(concept: Concept, localizations: Record<string, unkno
     // Designation-level relationship targets and ref text
     const rawTerms = rawObj.terms;
     if (Array.isArray(rawTerms)) {
-      for (let i = 0; i < lc.terms.length && i < rawTerms.length; i++) {
-        const rawTerm = rawTerms[i] as Record<string, unknown>;
-        const rawRelated = rawTerm.related;
+      for (const rawTerm of rawTerms) {
+        if (!rawTerm || typeof rawTerm !== 'object') continue;
+        const rawT = rawTerm as Record<string, unknown>;
+        const rawDesignation = rawT.designation as string | undefined;
+        if (!rawDesignation) continue;
+        const designation = lc.terms.find(d => d.designation === rawDesignation);
+        if (!designation) continue;
+        const rawRelated = rawT.related;
         if (!Array.isArray(rawRelated)) continue;
-        const designation = lc.terms[i];
-        for (let j = 0; j < designation.related.length && j < rawRelated.length; j++) {
-          const rawRel = rawRelated[j] as Record<string, unknown>;
-          const rc = designation.related[j];
-          if ('type' in rc) {
-            if (rawRel.target && typeof rawRel.target === 'string') {
-              designationTargets.set(rc as RelatedConcept, rawRel.target);
-            }
-            if ('ref' in rc && rc.ref) {
-              const rawRef = rawRel.ref as Record<string, unknown> | undefined;
-              if (rawRef?.text && typeof rawRef.text === 'string') {
-                refTexts.set((rc as RelatedConcept).ref!, rawRef.text);
-              }
+        for (const rawRel of rawRelated) {
+          if (!rawRel || typeof rawRel !== 'object') continue;
+          const rel = rawRel as Record<string, unknown>;
+          const relType = rel.type as string | undefined;
+          const rc = designation.related.find(r => r.type === relType);
+          if (!rc) continue;
+          if (rel.target && typeof rel.target === 'string') {
+            designationTargets.set(rc as object, rel.target);
+          }
+          if ('ref' in rc && rc.ref) {
+            const rawRef = rel.ref as Record<string, unknown> | undefined;
+            if (rawRef?.text && typeof rawRef.text === 'string') {
+              refTexts.set(rc.ref, rawRef.text);
             }
           }
         }
@@ -239,11 +244,14 @@ function attachAnnotations(concept: Concept, localizations: Record<string, unkno
     // Localization-level ref text
     const rawRelated = rawObj.related;
     if (Array.isArray(rawRelated)) {
-      for (let i = 0; i < lc.related.length && i < rawRelated.length; i++) {
-        const rc = lc.related[i];
-        const rawRel = rawRelated[i] as Record<string, unknown>;
-        const rawRef = rawRel.ref as Record<string, unknown> | undefined;
-        if (rc.ref && rawRef?.text && typeof rawRef.text === 'string') {
+      for (const rawRel of rawRelated) {
+        if (!rawRel || typeof rawRel !== 'object') continue;
+        const rel = rawRel as Record<string, unknown>;
+        const relType = rel.type as string | undefined;
+        const rc = relType ? lc.related.find(r => r.type === relType) : undefined;
+        if (!rc || !rc.ref) continue;
+        const rawRef = rel.ref as Record<string, unknown> | undefined;
+        if (rawRef?.text && typeof rawRef.text === 'string') {
           refTexts.set(rc.ref, rawRef.text);
         }
       }

package/src/adapters/ontology-registry.ts

@@ -1,5 +1,5 @@
 /**
- * Ontology Registry — taxonomy-driven labels and definitions for the browser.
+ * Ontology Registry — taxonomy-driven labels, definitions, and colors for the browser.
  *
  * All enumeration labels, definitions, and colors come from the SKOS taxonomy
  * data extracted at build time from concept-model/ontologies/taxonomies/*.ttl.
@@ -29,10 +29,19 @@ export interface Taxonomy {
   schemeDefinition: string | null;
   categories?: Record<string, TaxonomyCategory>;
   concepts: Record<string, TaxonomyConcept>;
+  colors?: Record<string, string>;
+}
+
+export interface TaxonomyDisplay {
+  label: string;
+  color: string;
+  definition?: string;
 }
 
 type TaxonomyKey = keyof typeof taxonomyData;
 
+const DEFAULT_COLOR = 'badge-gray';
+
 export class OntologyRegistry {
   private data: Record<string, Taxonomy>;
 
@@ -94,9 +103,17 @@ export class OntologyRegistry {
   }
 
   getColor(taxonomy: TaxonomyKey, id: string): string | null {
-    const entry = this.data[taxonomy] as unknown as Record<string, unknown>;
-    const colors = entry?.colors as Record<string, string> | undefined;
-    return colors?.[id] ?? null;
+    return this.data[taxonomy]?.colors?.[id] ?? null;
+  }
+
+  getDisplay(taxonomy: TaxonomyKey, id: string | null | undefined, colorFallback?: string): TaxonomyDisplay {
+    if (!id) return { label: '', color: colorFallback ?? DEFAULT_COLOR };
+    const concept = this.getConcept(taxonomy, id);
+    return {
+      label: concept?.prefLabel ?? id,
+      color: this.data[taxonomy]?.colors?.[id] ?? colorFallback ?? DEFAULT_COLOR,
+      definition: concept?.definition ?? undefined,
+    };
   }
 }
 

package/src/adapters/types.ts

@@ -116,6 +116,8 @@ export interface DatasetRegistry {
   datasetUri?: string;
   uriBase?: string;
   uriAliases?: string[];
+  ref?: string;
+  refAliases?: string[];
 }
 
 // ── Graph types ────────────────────────────────────────────────────────────