@glossarist/concept-browser 0.7.33 → 0.7.35

package/package.json

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

package/src/__tests__/concept-detail-interaction.test.ts

@@ -242,10 +242,6 @@ describe('ConceptDetail interactions', () => {
     // Register the URI pattern via factory so it resolves as internal
     const { getFactory } = await import('../adapters/factory');
     const factory = getFactory();
-    factory.router.registerDataset('test', '/data/test', {
-      ...makeManifest(),
-      uriBase: 'https://glossarist.org',
-    });
     factory.resolver.registerDataset('test', ['https://glossarist.org/test/concept/*']);
 
     const wrapper = mountDetail(json);

package/src/adapters/DatasetAdapter.ts

@@ -9,10 +9,9 @@ import type {
   SectionNode,
   DatasetSummary,
 } from './types';
-import type { Concept, LocalizedConcept, Designation, RelatedConcept } from 'glossarist';
-import { conceptFromJson, conceptUri } from './model-bridge';
-import { UriRouter } from './UriRouter';
-import { slugify } from '../utils/slugify';
+import type { Concept } from 'glossarist';
+import { conceptFromJson } from './model-bridge';
+import { GraphDataSource } from './GraphDataSource';
 
 // ── Wire-format types for JSON responses ────────────────────────────────────
 
@@ -33,36 +32,6 @@ interface IndexConceptJson {
   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: RelatedConcept, uriBase: string, registerId: string, urnMap?: ReadonlyMap<string, string>): string {
-  if (!rc.ref) return '';
-  const ref = rc.ref;
-  if (ref.id) {
-    let reg = registerId;
-    if (ref.source && !ref.source.startsWith('http')) {
-      reg = urnMap?.get(ref.source) ?? ref.source;
-    }
-    return `${uriBase}/${reg}/concept/${ref.id}`;
-  }
-  if (ref.source && ref.source.startsWith('http')) return ref.source;
-  return ref.source || '';
-}
-
 export class DatasetAdapter {
   private positionIndex = new Map<string, number>();
   private _urnMap: ReadonlyMap<string, string> = new Map();
@@ -376,131 +345,42 @@ export class DatasetAdapter {
     this._urnMap = map;
   }
 
-  extractEdges(concept: Concept): GraphEdge[] {
-    const edges: GraphEdge[] = [];
-    const uriBase = this.manifest?.uriBase || 'https://glossarist.org';
-    const sourceUri = concept.uri || `${uriBase}/${this.registerId}/concept/${concept.id}`;
-
-    // Managed concept level relationships
-    for (const rc of concept.relatedConcepts) {
-      const target = resolveRefTarget(rc, uriBase, this.registerId, this._urnMap);
-      if (target && target !== sourceUri) {
-        const parsed = UriRouter.parseUri(target);
-        edges.push({
-          source: sourceUri,
-          target,
-          type: rc.type || 'references',
-          label: rc.content || undefined,
-          register: parsed?.registerId ?? this.registerId,
-        });
-      }
-    }
-
-    // Per-localization references (from inline extraction in generate-data)
-    for (const lang of concept.languages) {
-      const lc = concept.localization(lang);
-      if (!lc) continue;
-      for (const rc of lc.related) {
-        const target = resolveRefTarget(rc, uriBase, this.registerId, this._urnMap);
-        if (target && target !== sourceUri) {
-          const parsed = UriRouter.parseUri(target);
-          edges.push({
-            source: sourceUri,
-            target,
-            type: rc.type || 'references',
-            label: rc.content || undefined,
-            register: parsed?.registerId ?? this.registerId,
-            lang,
-          });
-        }
-      }
-    }
-
-    return edges;
-  }
-
-  extractDomainEdges(concept: Concept): GraphEdge[] {
-    const edges: GraphEdge[] = [];
-    const uriBase = this.manifest?.uriBase || 'https://glossarist.org';
-    const sourceUri = concept.uri || `${uriBase}/${this.registerId}/concept/${concept.id}`;
-
-    for (const lang of concept.languages) {
-      const lc = concept.localization(lang);
-      if (lc?.domain) {
-        edges.push({
-          source: sourceUri,
-          target: `${uriBase}/${this.registerId}/domain/${slugify(lc.domain)}`,
-          type: 'domain',
-          label: lc.domain,
-          register: this.registerId,
-          lang,
-        });
-      }
-    }
-    return edges;
+  get dataUrl(): string {
+    return this.baseUrl;
   }
 
-  async loadDomainNodes(): Promise<GraphNode[]> {
-    const resp = await fetch(`${this.baseUrl}/domain-nodes.json`);
-    if (!resp.ok) return [];
-    const data = await resp.json();
-    return (data.domainNodes || []).map((dn: DomainNodeJson) => this.mapDomainNode(dn));
+  get urnMap(): ReadonlyMap<string, string> {
+    return this._urnMap;
   }
 
-  private mapDomainNode(dn: DomainNodeJson): GraphNode {
-    const node: GraphNode = {
-      uri: dn.uri ?? '',
-      register: dn.registerId ?? '',
-      conceptId: dn.uri?.split('/domain/')[1] || dn.id || '',
-      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) => this.mapSectionNode(c));
-    }
-    return node;
+  private _graphDataSource: GraphDataSource | null = null;
+  get graphDataSource(): GraphDataSource {
+    if (!this._graphDataSource) this._graphDataSource = new GraphDataSource(this);
+    return this._graphDataSource;
   }
 
-  private mapSectionNode(dn: DomainNodeJson): SectionNode {
-    const node: SectionNode = {
-      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) => this.mapSectionNode(c));
-    }
-    return node;
+  extractEdges(concept: Concept): GraphEdge[] {
+    return this.graphDataSource.extractEdges(concept);
   }
 
-  getSectionTree(): SectionNode[] {
-    const nodes = this.manifest?.sections;
-    if (!nodes || nodes.length === 0) return [];
-    return nodes.map(s => this.mapManifestSection(s));
+  extractDomainEdges(concept: Concept): GraphEdge[] {
+    return this.graphDataSource.extractDomainEdges(concept);
   }
 
-  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));
-    }
-    return node;
+  async loadDomainNodes(): Promise<GraphNode[]> {
+    return this.graphDataSource.loadDomainNodes();
   }
 
   async loadEdgeIndex(): Promise<GraphEdge[]> {
-    const resp = await fetch(`${this.baseUrl}/edges.json`);
-    if (!resp.ok) return [];
-    const data = await resp.json();
-    return data.edges ?? [];
+    return this.graphDataSource.loadEdgeIndex();
   }
 
   async loadGraphNodes(): Promise<{ uriPrefix: string; nodes: [string, Record<string, string>, string][] }> {
-    const resp = await fetch(`${this.baseUrl}/graph-nodes.json`);
-    if (!resp.ok) return { uriPrefix: '', nodes: [] };
-    return await resp.json();
+    return this.graphDataSource.loadGraphNodes();
+  }
+
+  getSectionTree(): SectionNode[] {
+    return this.graphDataSource.getSectionTree();
   }
 
   getLanguages(): string[] {

package/src/adapters/GraphDataSource.ts

@@ -0,0 +1,178 @@
+import type { GraphEdge, GraphNode, SectionNode } from './types';
+import type { Concept, RelatedConcept } from 'glossarist';
+import type { DatasetAdapter } from './DatasetAdapter';
+import { ReferenceResolver } from './ReferenceResolver';
+import { slugify } from '../utils/slugify';
+
+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: RelatedConcept, uriBase: string, registerId: string, urnMap?: ReadonlyMap<string, string>): string {
+  if (!rc.ref) return '';
+  const ref = rc.ref;
+  if (ref.id) {
+    let reg = registerId;
+    if (ref.source && !ref.source.startsWith('http')) {
+      reg = urnMap?.get(ref.source) ?? ref.source;
+    }
+    return `${uriBase}/${reg}/concept/${ref.id}`;
+  }
+  if (ref.source && ref.source.startsWith('http')) return ref.source;
+  return ref.source || '';
+}
+
+export class GraphDataSource {
+  constructor(private adapter: DatasetAdapter) {}
+
+  private get baseUrl(): string {
+    return this.adapter.dataUrl;
+  }
+
+  private get registerId(): string {
+    return this.adapter.registerId;
+  }
+
+  private get uriBase(): string {
+    return this.adapter.manifest?.uriBase || 'https://glossarist.org';
+  }
+
+  private get urnMap(): ReadonlyMap<string, string> {
+    return this.adapter.urnMap;
+  }
+
+  async loadEdgeIndex(): Promise<GraphEdge[]> {
+    const resp = await fetch(`${this.baseUrl}/edges.json`);
+    if (!resp.ok) return [];
+    const data = await resp.json();
+    return data.edges ?? [];
+  }
+
+  async loadGraphNodes(): Promise<{ uriPrefix: string; nodes: [string, Record<string, string>, string][] }> {
+    const resp = await fetch(`${this.baseUrl}/graph-nodes.json`);
+    if (!resp.ok) return { uriPrefix: '', nodes: [] };
+    return await resp.json();
+  }
+
+  async loadDomainNodes(): Promise<GraphNode[]> {
+    const resp = await fetch(`${this.baseUrl}/domain-nodes.json`);
+    if (!resp.ok) return [];
+    const data = await resp.json();
+    return (data.domainNodes || []).map((dn: DomainNodeJson) => this.mapDomainNode(dn));
+  }
+
+  extractEdges(concept: Concept): GraphEdge[] {
+    const edges: GraphEdge[] = [];
+    const sourceUri = concept.uri || `${this.uriBase}/${this.registerId}/concept/${concept.id}`;
+
+    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);
+        edges.push({
+          source: sourceUri,
+          target,
+          type: rc.type || 'references',
+          label: rc.content || undefined,
+          register: parsed?.registerId ?? this.registerId,
+        });
+      }
+    }
+
+    for (const lang of concept.languages) {
+      const lc = concept.localization(lang);
+      if (!lc) continue;
+      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);
+          edges.push({
+            source: sourceUri,
+            target,
+            type: rc.type || 'references',
+            label: rc.content || undefined,
+            register: parsed?.registerId ?? this.registerId,
+            lang,
+          });
+        }
+      }
+    }
+
+    return edges;
+  }
+
+  extractDomainEdges(concept: Concept): GraphEdge[] {
+    const edges: GraphEdge[] = [];
+    const sourceUri = concept.uri || `${this.uriBase}/${this.registerId}/concept/${concept.id}`;
+
+    for (const lang of concept.languages) {
+      const lc = concept.localization(lang);
+      if (lc?.domain) {
+        edges.push({
+          source: sourceUri,
+          target: `${this.uriBase}/${this.registerId}/domain/${slugify(lc.domain)}`,
+          type: 'domain',
+          label: lc.domain,
+          register: this.registerId,
+          lang,
+        });
+      }
+    }
+    return edges;
+  }
+
+  getSectionTree(): SectionNode[] {
+    const nodes = this.adapter.manifest?.sections;
+    if (!nodes || nodes.length === 0) return [];
+    return nodes.map(s => this.mapManifestSection(s));
+  }
+
+  private mapDomainNode(dn: DomainNodeJson): GraphNode {
+    const node: GraphNode = {
+      uri: dn.uri ?? '',
+      register: dn.registerId ?? '',
+      conceptId: dn.uri?.split('/domain/')[1] || dn.id || '',
+      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) => this.mapSectionNode(c));
+    }
+    return node;
+  }
+
+  private mapSectionNode(dn: DomainNodeJson): SectionNode {
+    const node: SectionNode = {
+      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) => this.mapSectionNode(c));
+    }
+    return node;
+  }
+
+  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));
+    }
+    return node;
+  }
+}

package/src/adapters/ReferenceResolver.ts

@@ -32,6 +32,13 @@ export class ReferenceResolver {
   private routing: RoutingEntry[] = [];
   private sourceRefs = new Map<string, { datasetId: string; uriPrefix: string }>();
 
+  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 });
   }
@@ -115,6 +122,23 @@ export class ReferenceResolver {
     return 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}`;
+    const resolution = this.resolveReference(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.resolveReference(directUri, sourceDatasetId);
+      if (directRes.type === 'internal') {
+        return { registerId: directRes.registerId, conceptId: directRes.conceptId.replace(/^\//, '') };
+      }
+    }
+    return null;
+  }
+
   private extractConceptIdFromRouting(uri: string, pattern: string): string | null {
     for (const ds of this.datasets) {
       for (const dsPattern of ds.uriPatterns) {

package/src/adapters/factory.ts

@@ -1,13 +1,11 @@
 import type { DatasetRegistry, Manifest, Resolution } from './types';
 import type { RoutingEntry as ConfigRoutingEntry } from '../config/types';
 import { DatasetAdapter } from './DatasetAdapter';
-import { UriRouter } from './UriRouter';
 import { ReferenceResolver } from './ReferenceResolver';
 
 export class AdapterFactory {
   private adapters = new Map<string, DatasetAdapter>();
   private urnMap = new Map<string, string>();
-  readonly router = new UriRouter();
   readonly resolver: ReferenceResolver;
   private crossRefIndex: Record<string, string[]> | null = null;
 
@@ -76,8 +74,6 @@ export class AdapterFactory {
   }
 
   private registerDataset(registerId: string, manifest: Manifest): void {
-    this.router.registerDataset(registerId, `${import.meta.env.BASE_URL}data/${registerId}`, manifest);
-
     const uriPatterns = [
       manifest.datasetUri,
       ...(manifest.uriAliases ?? []),
@@ -117,20 +113,7 @@ export class AdapterFactory {
   }
 
   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;
+    return this.resolver.resolveRelatedRef(ref, sourceDatasetId);
   }
 
   resolveCitation(source: string, referenceFrom: string, sourceDatasetId?: string): Resolution | null {

package/src/components/ConceptDetail.vue

@@ -1,21 +1,21 @@
 <script setup lang="ts">
-import type { Concept, LocalizedConcept, Designation, ConceptSource } from 'glossarist';
+import type { Concept, LocalizedConcept, Designation } from 'glossarist';
 import type { Manifest, GraphEdge } from '../adapters/types';
 import { computed, ref, nextTick, watch } from 'vue';
-import { langName, langLabel, sortLanguages } from '../utils/lang';
-import { renderMath, cleanContent } from '../utils/math';
+import { langName } from '../utils/lang';
+import { renderMath } from '../utils/math';
 import type { RenderOptions } from '../utils/math';
 import { escapeAttr } from '../utils/escape';
 import { entryStatusColor, conceptStatusColor, conceptStatusLabel, conceptStatusDefinition, entryStatusLabel, entryStatusDefinition, getPreferredTerm } from '../utils/concept-helpers';
 import { sourceTypeInfo, sourceStatusInfo } from '../utils/designation-registry';
-import { conceptUri, getAnnotations } from '../adapters/model-bridge';
+import { conceptUri } from '../adapters/model-bridge';
 import { useRouter } from 'vue-router';
 import { useVocabularyStore } from '../stores/vocabulary';
 import { useDsStyle } from '../utils/dataset-style';
 import { getFactory } from '../adapters/factory';
 import { useRenderOptions } from '../composables/use-render-options';
 import { useConceptEdges } from '../composables/use-concept-edges';
-import { useConceptContent, type LangContent } from '../composables/use-concept-content';
+import { useConceptContent } from '../composables/use-concept-content';
 import { relationshipLabel, INVERSE_RELATIONSHIPS } from '../utils/relationship-categories';
 import { slugify } from '../utils/slugify';
 import { useSiteConfig } from '../config/use-site-config';
@@ -72,7 +72,7 @@ const {
   relatedLabel,
   navigateEdge,
   navigateRelated,
-} = useConceptEdges(conceptComputed, registerIdComputed, manifestComputed, edgesComputed);
+} = useConceptEdges(conceptComputed, registerIdComputed, manifestComputed, edgesComputed, router);
 
 const uriCopied = ref(false);
 function copyUri() {
@@ -83,21 +83,6 @@ function copyUri() {
   });
 }
 
-const languages = computed(() => {
-  const sorted = sortLanguages(props.concept.languages, props.manifest.languageOrder);
-  // Put current UI locale first
-  const current = locale.value;
-  const idx = sorted.indexOf(current);
-  if (idx > 0) {
-    sorted.splice(idx, 1);
-    sorted.unshift(current);
-  }
-  return sorted;
-});
-
-// Collapsible language sections — expand all with content, collapse those without
-const collapsedLangs = ref(new Set<string>());
-
 const engConcept = computed((): LocalizedConcept | null => {
   return props.concept.localization('eng') ?? null;
 });
@@ -115,12 +100,10 @@ const conceptSources = computed(() => props.concept.sources);
 
 const conceptTags = computed(() => props.concept.tags ?? []);
 
-// Cross-reference resolver: generates clickable links for inline refs
-
 const factory = getFactory();
 const { ensureBibLoaded, bibResolver, figResolver } = useRenderOptions(() => props.registerId);
 
-const renderOpts: RenderOptions = {
+const renderOpts = computed<RenderOptions>(() => ({
   xrefResolver: (uri, term) => {
     const resolution = factory.resolve(uri, props.registerId);
     if (resolution.type === 'internal') {
@@ -139,11 +122,10 @@ const renderOpts: RenderOptions = {
   },
   bibResolver,
   figResolver,
-};
+}));
 
 watch(() => props.registerId, () => { ensureBibLoaded(); }, { immediate: true });
 
-// Handle clicks on cross-reference links via event delegation
 function handleContentClick(e: MouseEvent) {
   const target = (e.target as HTMLElement).closest('.xref-link') as HTMLElement | null;
   if (!target) return;
@@ -155,86 +137,18 @@ function handleContentClick(e: MouseEvent) {
   }
 }
 
-// LangContent type is imported from the composable
-
-const allLangContent = computed(() => {
-  const result: LangContent[] = [];
-  for (const lang of languages.value) {
-    const lc = props.concept.localization(lang);
-    if (!lc) continue;
-
-    const definition = lc.definitions
-      .map(d => d.content).filter(Boolean).join('\n\n');
-    const annotations = getAnnotations(lc).map(a => a.content).filter(Boolean);
-    const notes = lc.notes.map(n => n.content).filter(Boolean);
-    const examples = lc.examples.map(e => e.content).filter(Boolean);
-
-    result.push({
-      lang,
-      lc,
-      renderedTerm: renderMath(getPreferredTerm(lc, '')),
-      definition,
-      renderedDefinition: renderMath(definition, renderOpts),
-      annotations,
-      renderedAnnotations: annotations.map((a: string) => renderMath(a, renderOpts)),
-      notes,
-      renderedNotes: notes.map(n => renderMath(n, renderOpts)),
-      examples,
-      renderedExamples: examples.map(e => renderMath(e, renderOpts)),
-      sources: lc.sources,
-      designations: lc.terms,
-      renderedDesignations: new Map(lc.terms.map(d => [d.designation, renderMath(d.designation)])),
-      entryStatus: lc.entryStatus ?? '',
-      classification: lc.classification,
-      reviewType: lc.reviewType,
-      release: lc.release,
-      lineageSourceSimilarity: lc.lineageSourceSimilarity,
-      lcScript: lc.script,
-      lcSystem: lc.system,
-    });
-  }
-  return result;
-});
-
-const langContentMap = computed(() => {
-  const map = new Map<string, LangContent>();
-  for (const lc of allLangContent.value) map.set(lc.lang, lc);
-  return map;
-});
-
-function hasContent(lc: LangContent): boolean {
-  return !!(lc.definition || lc.annotations.length || lc.notes.length || lc.examples.length || lc.sources.length);
-}
-
-function initCollapsed() {
-  const mainLangs = siteConfig.value?.defaults?.mainLanguages || [];
-  const mainSet = new Set(mainLangs.length ? mainLangs : ['eng']);
-  const collapsed = new Set<string>();
-  for (const lc of allLangContent.value) {
-    if (!hasContent(lc) && !mainSet.has(lc.lang)) {
-      collapsed.add(lc.lang);
-    }
-  }
-  collapsedLangs.value = collapsed;
-}
-
-watch(languages, () => { initCollapsed(); }, { immediate: true });
-
-const allCollapsed = computed(() => collapsedLangs.value.size === allLangContent.value.length);
-
-function toggleLang(lang: string) {
-  const s = new Set(collapsedLangs.value);
-  if (s.has(lang)) s.delete(lang); else s.add(lang);
-  collapsedLangs.value = s;
-}
-
-function toggleAll() {
-  if (allCollapsed.value) {
-    collapsedLangs.value = new Set();
-  } else {
-    collapsedLangs.value = new Set(allLangContent.value.map(lc => lc.lang));
-  }
-}
+const {
+  languages,
+  allLangContent,
+  langContentMap,
+  hasContent,
+  collapsedLangs,
+  allCollapsed,
+  toggleLang,
+  toggleAll,
+  plainTruncate,
+  orderedDesignations,
+} = useConceptContent(conceptComputed, manifestComputed, renderOpts);
 
 function scrollToLang(lang: string) {
   if (collapsedLangs.value.has(lang)) {
@@ -263,14 +177,6 @@ function getDesignationsForLang(lang: string): Designation[] {
   return lc?.terms ?? [];
 }
 
-function orderedDesignations(lang: string): Designation[] {
-  const desigs = getDesignationsForLang(lang);
-  const preferred = desigs.filter(d => d.normativeStatus === 'preferred');
-  const admitted = desigs.filter(d => d.normativeStatus === 'admitted' || d.normativeStatus === 'deprecated');
-  const rest = desigs.filter(d => d.normativeStatus !== 'preferred' && d.normativeStatus !== 'admitted' && d.normativeStatus !== 'deprecated');
-  return [...preferred, ...admitted, ...rest];
-}
-
 function hasDefinition(lang: string): boolean {
   const lc = props.concept.localization(lang);
   if (!lc) return false;
@@ -282,16 +188,9 @@ function goAdjacent(id: string) {
   window.scrollTo({ top: 0, behavior: 'smooth' });
 }
 
-function plainTruncate(html: string, max: number = 120): string {
-  const text = cleanContent(html).replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim();
-  return text.length <= max ? text : text.slice(0, max).trimEnd() + '…';
-}
-
-// Domain rendering: merge ConceptReference domains and per-localization domain strings
 const conceptDomains = computed(() => {
   const domainMap = new Map<string, { slug: string; label: string; langs: string[]; conceptId?: string }>();
 
-  // Managed concept level ConceptReference domains (authoritative)
   for (const ref of conceptRefDomains.value) {
     const id = ref.conceptId ?? '';
     const label = id || ref.urn || '';
@@ -301,7 +200,6 @@ const conceptDomains = computed(() => {
     }
   }
 
-  // Per-localization domain strings
   for (const lang of props.concept.languages) {
     const lc = props.concept.localization(lang);
     const domain = lc?.domain;
@@ -318,7 +216,6 @@ const conceptDomains = computed(() => {
   return [...domainMap.values()].sort((a, b) => b.langs.length - a.langs.length);
 });
 
-// Non-verbal reps: aggregate across all localizations
 const nonVerbalReps = computed(() => {
   const reps: typeof import('glossarist').NonVerbRep.prototype[] = [];
   for (const lang of props.concept.languages) {
@@ -329,7 +226,6 @@ const nonVerbalReps = computed(() => {
   }
   return reps;
 });
-
 </script>
 
 <template>

package/src/composables/use-concept-edges.ts

@@ -1,4 +1,5 @@
 import { computed, type ComputedRef } from 'vue';
+import type { Router } from 'vue-router';
 import type { Concept, RelatedConcept } from 'glossarist';
 import type { Manifest, GraphEdge } from '../adapters/types';
 import { getFactory } from '../adapters/factory';
@@ -24,6 +25,7 @@ export function useConceptEdges(
   registerId: ComputedRef<string>,
   manifest: ComputedRef<Manifest>,
   edges: ComputedRef<GraphEdge[]>,
+  router: Router,
 ) {
   const factory = getFactory();
   const store = useVocabularyStore();
@@ -145,7 +147,6 @@ export function useConceptEdges(
   async function navigateEdge(edge: GraphEdge) {
     const uri = edge.source === conceptUriValue.value ? edge.target : edge.source;
     const resolution = factory.resolve(uri);
-    const router = (await import('vue-router')).useRouter();
 
     if (resolution.type === 'internal') {
       router.push({ name: 'concept', params: { registerId: resolution.registerId, conceptId: resolution.conceptId } });
@@ -159,7 +160,6 @@ export function useConceptEdges(
   async function navigateRelated(ref: { source: string | null; id: string | null }) {
     const target = resolveRelatedRef(ref);
     if (!target) return;
-    const router = (await import('vue-router')).useRouter();
     router.push({ name: 'concept', params: { registerId: target.registerId, conceptId: target.conceptId } });
   }
 

package/src/composables/use-ontology-nav.ts

@@ -26,51 +26,6 @@ export function compactToSlug(compact: string): string {
   return compact.replace(/:/g, '-');
 }
 
-const expandedClasses = ref(new Set<string>(['gloss:Designation']));
-
-const collapsedSections = ref(new Set<string>([
-  'objectProperty',
-  'datatypeProperty',
-  'shape',
-  'taxonomy',
-  'namedIndividual',
-  'annotationProperty',
-]));
-
-const searchQuery = ref('');
-
-function toggleExpand(cls: OwlClass) {
-  const s = new Set(expandedClasses.value);
-  if (s.has(cls.compact)) s.delete(cls.compact);
-  else s.add(cls.compact);
-  expandedClasses.value = s;
-}
-
-function toggleSection(key: string) {
-  const s = new Set(collapsedSections.value);
-  if (s.has(key)) s.delete(key);
-  else s.add(key);
-  collapsedSections.value = s;
-}
-
-function expandAllSections() {
-  collapsedSections.value = new Set();
-}
-
-function collapseAllSections() {
-  collapsedSections.value = new Set(['objectProperty', 'datatypeProperty', 'shape', 'taxonomy', 'class', 'namedIndividual', 'annotationProperty']);
-}
-
-function childClasses(parentId: string): OwlClass[] {
-  const cls = getClass(parentId);
-  if (!cls) return [];
-  return cls.children.map(id => getClass(id)).filter((c): c is OwlClass => !!c);
-}
-
-function hasChildren(cls: OwlClass): boolean {
-  return cls.children.length > 0;
-}
-
 const treeRoots = getClassTree();
 const allShapes = getAllShapes();
 const objectProperties = getObjectProperties();
@@ -97,28 +52,6 @@ const taxonomyLabels: Record<string, string> = {
   grammarNumber: 'Grammar Number',
 };
 
-interface IndividualGroup {
-  key: string;
-  label: string;
-  concepts: { id: string; prefLabel: string }[];
-}
-
-const groupedIndividuals = computed<IndividualGroup[]>(() => {
-  return taxonomyKeys.map(key => {
-    const tax = (taxonomyData as Record<string, any>)[key];
-    if (!tax) return { key, label: taxonomyLabels[key] || key, concepts: [] };
-    const concepts = Object.values(tax.concepts as Record<string, any>).map((c: any) => ({
-      id: c.id,
-      prefLabel: c.prefLabel,
-    }));
-    return { key, label: tax.schemeLabel || taxonomyLabels[key] || key, concepts };
-  });
-});
-
-const totalIndividuals = computed(() =>
-  groupedIndividuals.value.reduce((sum, g) => sum + g.concepts.length, 0),
-);
-
 const valuesToTaxonomy: Record<string, string> = {
   'gloss:status': 'conceptStatus',
   'gloss:entstatus': 'entryStatus',
@@ -132,6 +65,20 @@ const valuesToTaxonomy: Record<string, string> = {
   'gloss:number': 'grammarNumber',
 };
 
+function childClasses(parentId: string): OwlClass[] {
+  const cls = getClass(parentId);
+  if (!cls) return [];
+  return cls.children.map(id => getClass(id)).filter((c): c is OwlClass => !!c);
+}
+
+function hasChildren(cls: OwlClass): boolean {
+  return cls.children.length > 0;
+}
+
+function matchesSearch(text: string, query: string): boolean {
+  return text.toLowerCase().includes(query.toLowerCase());
+}
+
 function taxonomyKeyForValuesFrom(valuesFrom: string | null): string | null {
   if (!valuesFrom) return null;
   return valuesToTaxonomy[valuesFrom] ?? null;
@@ -145,80 +92,126 @@ function getShapesForTaxonomy(taxonomyKey: string): OwlShape[] {
   );
 }
 
-const allNavItems = computed(() => {
-  const items: { id: string; label: string; depth: number }[] = [];
-  function walk(classes: OwlClass[], depth: number) {
-    for (const cls of classes) {
-      items.push({ id: cls.compact, label: cls.label, depth });
-      if (expandedClasses.value.has(cls.compact)) {
-        walk(childClasses(cls.compact), depth + 1);
-      }
-    }
+export function useOntologyNav() {
+  const expandedClasses = ref(new Set<string>(['gloss:Designation']));
+
+  const collapsedSections = ref(new Set<string>([
+    'objectProperty',
+    'datatypeProperty',
+    'shape',
+    'taxonomy',
+    'namedIndividual',
+    'annotationProperty',
+  ]));
+
+  const searchQuery = ref('');
+
+  function toggleExpand(cls: OwlClass) {
+    const s = new Set(expandedClasses.value);
+    if (s.has(cls.compact)) s.delete(cls.compact);
+    else s.add(cls.compact);
+    expandedClasses.value = s;
   }
-  walk(treeRoots, 0);
-  return items;
-});
-
-function matchesSearch(text: string, query: string): boolean {
-  return text.toLowerCase().includes(query.toLowerCase());
-}
 
-const searchResults = computed(() => {
-  const q = searchQuery.value.trim();
-  if (!q) return null;
-
-  const matchedClasses: OwlClass[] = [];
-  const matchedObjectProps: OwlProperty[] = [];
-  const matchedDatatypeProps: OwlProperty[] = [];
-  const matchedShapes: OwlShape[] = [];
-  const matchedIndividuals: { group: string; id: string; prefLabel: string }[] = [];
-  const matchedAnnotationProps: AnnotationProperty[] = [];
-
-  // Walk all classes (tree + leaves)
-  function walkAll(classes: OwlClass[]) {
-    for (const cls of classes) {
-      if (matchesSearch(cls.label, q) || matchesSearch(cls.compact, q)) {
-        matchedClasses.push(cls);
-      }
-      walkAll(childClasses(cls.compact));
-    }
+  function toggleSection(key: string) {
+    const s = new Set(collapsedSections.value);
+    if (s.has(key)) s.delete(key);
+    else s.add(key);
+    collapsedSections.value = s;
   }
-  walkAll(treeRoots);
 
-  for (const p of objectProperties) {
-    if (matchesSearch(p.label, q) || matchesSearch(p.compact, q)) matchedObjectProps.push(p);
+  function expandAllSections() {
+    collapsedSections.value = new Set();
   }
-  for (const p of datatypeProperties) {
-    if (matchesSearch(p.label, q) || matchesSearch(p.compact, q)) matchedDatatypeProps.push(p);
-  }
-  for (const s of allShapes) {
-    if (matchesSearch(s.label, q) || matchesSearch(s.compact, q)) matchedShapes.push(s);
+
+  function collapseAllSections() {
+    collapsedSections.value = new Set(['objectProperty', 'datatypeProperty', 'shape', 'taxonomy', 'class', 'namedIndividual', 'annotationProperty']);
   }
-  for (const g of groupedIndividuals.value) {
-    for (const c of g.concepts) {
-      if (matchesSearch(c.prefLabel, q) || matchesSearch(c.id, q)) {
-        matchedIndividuals.push({ group: g.key, id: c.id, prefLabel: c.prefLabel });
+
+  const allNavItems = computed(() => {
+    const items: { id: string; label: string; depth: number }[] = [];
+    function walk(classes: OwlClass[], depth: number) {
+      for (const cls of classes) {
+        items.push({ id: cls.compact, label: cls.label, depth });
+        if (expandedClasses.value.has(cls.compact)) {
+          walk(childClasses(cls.compact), depth + 1);
+        }
       }
     }
-  }
-  for (const ap of annotationProperties) {
-    if (matchesSearch(ap.label, q) || matchesSearch(ap.compact, q)) matchedAnnotationProps.push(ap);
-  }
+    walk(treeRoots, 0);
+    return items;
+  });
 
-  const total = matchedClasses.length + matchedObjectProps.length + matchedDatatypeProps.length + matchedShapes.length + matchedIndividuals.length + matchedAnnotationProps.length;
+  const searchResults = computed(() => {
+    const q = searchQuery.value.trim();
+    if (!q) return null;
+
+    const matchedClasses: OwlClass[] = [];
+    const matchedObjectProps: OwlProperty[] = [];
+    const matchedDatatypeProps: OwlProperty[] = [];
+    const matchedShapes: OwlShape[] = [];
+    const matchedIndividuals: { group: string; id: string; prefLabel: string }[] = [];
+    const matchedAnnotationProps: AnnotationProperty[] = [];
+
+    function walkAll(classes: OwlClass[]) {
+      for (const cls of classes) {
+        if (matchesSearch(cls.label, q) || matchesSearch(cls.compact, q)) {
+          matchedClasses.push(cls);
+        }
+        walkAll(childClasses(cls.compact));
+      }
+    }
+    walkAll(treeRoots);
 
-  return {
-    total,
-    classes: matchedClasses,
-    objectProperties: matchedObjectProps,
-    datatypeProperties: matchedDatatypeProps,
-    shapes: matchedShapes,
-    individuals: matchedIndividuals,
-    annotationProperties: matchedAnnotationProps,
-  };
-});
+    for (const p of objectProperties) {
+      if (matchesSearch(p.label, q) || matchesSearch(p.compact, q)) matchedObjectProps.push(p);
+    }
+    for (const p of datatypeProperties) {
+      if (matchesSearch(p.label, q) || matchesSearch(p.compact, q)) matchedDatatypeProps.push(p);
+    }
+    for (const s of allShapes) {
+      if (matchesSearch(s.label, q) || matchesSearch(s.compact, q)) matchedShapes.push(s);
+    }
+    for (const g of groupedIndividuals.value) {
+      for (const c of g.concepts) {
+        if (matchesSearch(c.prefLabel, q) || matchesSearch(c.id, q)) {
+          matchedIndividuals.push({ group: g.key, id: c.id, prefLabel: c.prefLabel });
+        }
+      }
+    }
+    for (const ap of annotationProperties) {
+      if (matchesSearch(ap.label, q) || matchesSearch(ap.compact, q)) matchedAnnotationProps.push(ap);
+    }
+
+    const total = matchedClasses.length + matchedObjectProps.length + matchedDatatypeProps.length + matchedShapes.length + matchedIndividuals.length + matchedAnnotationProps.length;
+
+    return {
+      total,
+      classes: matchedClasses,
+      objectProperties: matchedObjectProps,
+      datatypeProperties: matchedDatatypeProps,
+      shapes: matchedShapes,
+      individuals: matchedIndividuals,
+      annotationProperties: matchedAnnotationProps,
+    };
+  });
+
+  const groupedIndividuals = computed<IndividualGroup[]>(() => {
+    return taxonomyKeys.map(key => {
+      const tax = (taxonomyData as Record<string, any>)[key];
+      if (!tax) return { key, label: taxonomyLabels[key] || key, concepts: [] };
+      const concepts = Object.values(tax.concepts as Record<string, any>).map((c: any) => ({
+        id: c.id,
+        prefLabel: c.prefLabel,
+      }));
+      return { key, label: tax.schemeLabel || taxonomyLabels[key] || key, concepts };
+    });
+  });
+
+  const totalIndividuals = computed(() =>
+    groupedIndividuals.value.reduce((sum, g) => sum + g.concepts.length, 0),
+  );
 
-export function useOntologyNav() {
   return {
     expandedClasses,
     collapsedSections,
@@ -248,3 +241,9 @@ export function useOntologyNav() {
     ENTITY_TYPE_META,
   };
 }
+
+interface IndividualGroup {
+  key: string;
+  label: string;
+  concepts: { id: string; prefLabel: string }[];
+}

package/src/graph/GraphEngine.ts

@@ -1,5 +1,5 @@
 import type { GraphNode, GraphEdge } from '../adapters/types';
-import { UriRouter } from '../adapters/UriRouter';
+import { ReferenceResolver } from '../adapters/ReferenceResolver';
 
 function hasDesignations(node: GraphNode): boolean {
   const d = node.designations;
@@ -33,9 +33,9 @@ export class GraphEngine {
     if (this.edgeKeys.has(key)) return;
     this.edgeKeys.add(key);
 
-    const parsed = UriRouter.parseUri(edge.target);
+    const parsed = ReferenceResolver.parseUri(edge.target);
     if (!this.nodes.has(edge.source)) {
-      const sourceParsed = UriRouter.parseUri(edge.source);
+      const sourceParsed = ReferenceResolver.parseUri(edge.source);
       this.nodes.set(edge.source, {
         uri: edge.source,
         register: sourceParsed?.registerId ?? edge.register,
@@ -161,6 +161,71 @@ export class GraphEngine {
     return [...this.nodes.values()];
   }
 
+  // ── Bulk seeding: accept domain-level data, construct nodes internally ──────
+
+  addGraphNodes(uriPrefix: string, registerId: string, nodes: [string, Record<string, string>, string][]): void {
+    for (const [id, designations, status] of nodes) {
+      this.addNode({
+        uri: uriPrefix + id,
+        register: registerId,
+        conceptId: id,
+        designations: designations || {},
+        status: status || 'unknown',
+        loaded: false,
+      });
+    }
+  }
+
+  addEdges(edges: GraphEdge[]): void {
+    for (const edge of edges) {
+      this.addEdge(edge);
+    }
+  }
+
+  addDomainNodes(nodes: GraphNode[]): void {
+    for (const node of nodes) {
+      this.addNode(node);
+    }
+  }
+
+  seedConceptNode(uri: string, registerId: string, conceptId: string, designations: Record<string, string>, status: string): void {
+    this.addNode({
+      uri,
+      register: registerId,
+      conceptId,
+      designations,
+      status,
+      loaded: true,
+    });
+  }
+
+  addDomainEdgesWithNodes(edges: GraphEdge[], registerId: string): void {
+    for (const edge of edges) {
+      // Create domain target node before addEdge so addEdge finds it and skips stub creation
+      if (!this.nodes.has(edge.target)) {
+        this.nodes.set(edge.target, {
+          uri: edge.target,
+          register: registerId,
+          conceptId: '',
+          designations: edge.label ? { eng: edge.label } : {},
+          status: 'domain',
+          loaded: true,
+          nodeType: 'domain',
+        });
+      }
+      this.addEdge(edge);
+    }
+  }
+
+  getRelated(uri: string): { outgoing: GraphEdge[]; incoming: GraphEdge[] } {
+    return {
+      outgoing: this.getUniqueEdges(uri, 'outgoing', 'target')
+        .filter(e => e.type !== 'domain' && e.type !== 'section'),
+      incoming: this.getUniqueEdges(uri, 'incoming', 'source')
+        .filter(e => e.type !== 'domain' && e.type !== 'section'),
+    };
+  }
+
   get nodeCount(): number {
     return this.nodes.size;
   }

package/src/stores/vocabulary.ts

@@ -6,7 +6,7 @@ import type { Manifest, SearchHit, GraphEdge } from '../adapters/types';
 import type { Concept } from 'glossarist';
 import { conceptUri } from '../adapters/model-bridge';
 import { GraphEngine } from '../graph';
-import { UriRouter } from '../adapters/UriRouter';
+import { ReferenceResolver } from '../adapters/ReferenceResolver';
 import { deduplicateSearchHits } from '../utils/search';
 
 export const useVocabularyStore = defineStore('vocabulary', () => {
@@ -107,31 +107,17 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
           adapter.loadDomainNodes(),
         ]);
 
-        if (nodeResult.status === 'fulfilled') {
-          const { uriPrefix, nodes } = nodeResult.value;
-          for (const [id, designations, status] of nodes) {
-            engine.addNode({
-              uri: uriPrefix + id,
-              register: adapter.registerId,
-              conceptId: id,
-              designations: designations || {},
-              status: status || 'unknown',
-              loaded: false,
-            });
-          }
+        if (nodeResult.status === 'fulfilled' && nodeResult.value.uriPrefix) {
+          engine.addGraphNodes(nodeResult.value.uriPrefix, adapter.registerId, nodeResult.value.nodes);
         }
 
         if (edgeResult.status === 'fulfilled' && Array.isArray(edgeResult.value)) {
-          for (const edge of edgeResult.value) {
-            engine.addEdge(edge);
-          }
+          engine.addEdges(edgeResult.value);
           edgeStatus.value[adapter.registerId] = { loaded: true, count: edgeResult.value.length };
         }
 
         if (domainResult.status === 'fulfilled') {
-          for (const dn of domainResult.value) {
-            engine.addNode(dn);
-          }
+          engine.addDomainNodes(domainResult.value);
         }
       } catch {
         // Individual adapter failures are non-critical for graph view
@@ -149,24 +135,11 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
         adapter.loadGraphNodes(),
       ]);
       const engine = graph.value;
-      for (const dn of domainNodes) {
-        engine.addNode(dn);
-      }
+      engine.addDomainNodes(domainNodes);
       if (graphNodes.uriPrefix) {
-        for (const [id, designations, status] of graphNodes.nodes) {
-          engine.addNode({
-            uri: graphNodes.uriPrefix + id,
-            register: adapter.registerId,
-            conceptId: id,
-            designations: designations || {},
-            status: status || 'unknown',
-            loaded: false,
-          });
-        }
-      }
-      for (const edge of edges) {
-        engine.addEdge(edge);
+        engine.addGraphNodes(graphNodes.uriPrefix, adapter.registerId, graphNodes.nodes);
       }
+      engine.addEdges(edges);
       edgeStatus.value[adapter.registerId] = { loaded: true, count: edges.length };
       return edges;
     } catch {
@@ -186,7 +159,7 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
     if (adapter && loadedEdges.length > 0) {
       const targetRegisters = new Set<string>();
       for (const edge of loadedEdges) {
-        const parsed = UriRouter.parseUri(edge.target);
+        const parsed = ReferenceResolver.parseUri(edge.target);
         if (parsed?.registerId && parsed.registerId !== registerId) {
           targetRegisters.add(parsed.registerId);
         }
@@ -197,17 +170,7 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
         try {
           const gn = await targetAdapter.loadGraphNodes();
           if (gn.uriPrefix) {
-            const engine = graph.value;
-            for (const [id, designations, status] of gn.nodes) {
-              engine.addNode({
-                uri: gn.uriPrefix + id,
-                register: targetId,
-                conceptId: id,
-                designations: designations || {},
-                status: status || 'unknown',
-                loaded: false,
-              });
-            }
+            graph.value.addGraphNodes(gn.uriPrefix, targetId, gn.nodes);
           }
         } catch { /* non-critical */ }
       }));
@@ -261,36 +224,12 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
       }
 
       const engine = graph.value;
-      engine.addNode({
-        uri,
-        register: registerId,
-        conceptId,
-        designations,
-        status: indexEntry?.status ?? 'unknown',
-        loaded: true,
-      });
-
-      for (const edge of domainEdges) {
-        engine.addEdge(edge);
-        const existing = engine.getNode(edge.target);
-        if (!existing || !existing.loaded) {
-          engine.addNode({
-            uri: edge.target,
-            register: registerId,
-            conceptId: '',
-            designations: edge.label ? { eng: edge.label } : {},
-            status: 'domain',
-            loaded: true,
-            nodeType: 'domain',
-          });
-        }
-      }
+      engine.seedConceptNode(uri, registerId, conceptId, designations, indexEntry?.status ?? 'unknown');
+      engine.addDomainEdgesWithNodes(domainEdges, registerId);
 
       touchGraph();
-      conceptEdges.value = [
-        ...engine.getEdges(uri),
-        ...engine.getIncomingEdges(uri),
-      ];
+      const related = engine.getRelated(uri);
+      conceptEdges.value = [...related.outgoing, ...related.incoming];
     } catch (e: unknown) {
       error.value = `Failed to load concept ${conceptId}: ${e instanceof Error ? e.message : String(e)}`;
       currentConcept.value = null;