@glossarist/concept-browser 0.2.3 → 0.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -22,7 +22,7 @@
     "@vitejs/plugin-vue": "^5.2.3",
     "autoprefixer": "^10.4.21",
     "d3": "^7.9.0",
-    "glossarist": "^0.1.1",
+    "glossarist": "^0.2.0",
     "js-yaml": "^4.1.0",
     "katex": "^0.16.45",
     "pinia": "^2.3.1",

package/scripts/fetch-datasets.mjs

@@ -15,7 +15,7 @@
  */
 import fs from 'fs';
 import path from 'path';
-import yaml from 'js-yaml';
+import { loadGcr } from 'glossarist';
 import { execSync } from 'child_process';
 import { loadSiteConfig } from './load-site-config.mjs';
 
@@ -58,11 +58,17 @@ function extractGcr(gcrPath, targetDir) {
   console.log(`  Extracted to ${targetDir}`);
 }
 
-// --- Read GCR metadata from extracted dir ---
-function readGcrMetadata(targetDir) {
-  const metaPath = path.join(targetDir, 'metadata.yaml');
-  if (!fs.existsSync(metaPath)) return null;
-  return yaml.load(fs.readFileSync(metaPath, 'utf8'));
+// --- Read GCR metadata from ZIP without extraction ---
+async function readGcrMetadata(gcrPath) {
+  if (!fs.existsSync(gcrPath)) return null;
+  try {
+    const buf = fs.readFileSync(gcrPath);
+    const pkg = await loadGcr(buf);
+    const meta = await pkg.metadata();
+    return meta ? meta.toJSON() : null;
+  } catch {
+    return null;
+  }
 }
 
 // --- Dependency validation ---
@@ -167,11 +173,11 @@ for (const ds of config.datasets) {
       }
     }
 
-    // Read metadata for dependency validation
-    const meta = readGcrMetadata(targetDir);
+    // Read metadata for dependency validation (from GCR ZIP, not extracted dir)
+    const meta = await readGcrMetadata(gcrPath);
     if (meta) {
       gcrMetadata[ds.id] = meta;
-      console.log(`  ${meta.statistics?.total_concepts || '?'} concepts, ${meta.uri || 'no uri'}`);
+      console.log(`  ${meta.concept_count || '?'} concepts, ${meta.uri_prefix || 'no uri'}`);
     }
   } catch (e) {
     console.warn(`  Failed: ${e.message}`);

package/scripts/generate-data.mjs

@@ -98,9 +98,72 @@ function refsToJsonLd(refs) {
   })).filter(r => r['@id']);
 }
 
+function buildRefMaps(config) {
+  const refPrefixMap = {};
+  const urnStandardMap = {};
+
+  for (const ds of config.datasets) {
+    const uri = ds.uri || '';
+    const urnMatch = uri.match(/^urn:iso:std:iso:(\d+):\*$/);
+    if (urnMatch) urnStandardMap[urnMatch[1]] = ds.id;
+  }
+
+  for (const route of config.routing || []) {
+    if (route.uri && route.uri.includes('iec') && route.uri.includes('60050')) {
+      const mapped = route.targetDataset;
+      if (mapped) refPrefixMap['IEV'] = mapped;
+    }
+  }
+
+  const xref = config.crossReferences || {};
+  if (xref.refPrefixMap) Object.assign(refPrefixMap, xref.refPrefixMap);
+  if (xref.urnStandardMap) Object.assign(urnStandardMap, xref.urnStandardMap);
+
+  return { refPrefixMap, urnStandardMap };
+}
+
+function extractInlineRefs(localizedData, refPrefixMap, urnStandardMap) {
+  const refs = [];
+  const texts = [];
+
+  if (localizedData.definition) {
+    const defs = Array.isArray(localizedData.definition) ? localizedData.definition : [localizedData.definition];
+    for (const d of defs) texts.push(typeof d === 'string' ? d : (d.content || ''));
+  }
+  if (localizedData.notes) {
+    for (const n of localizedData.notes) texts.push(typeof n === 'string' ? n : (n.content || ''));
+  }
+  if (localizedData.examples) {
+    for (const e of localizedData.examples) texts.push(typeof e === 'string' ? e : (e.content || ''));
+  }
+  const fullText = texts.join(' ');
+
+  for (const m of fullText.matchAll(/\{\{([^,}]+),\s*IEV:([^}]+)\}\}/g)) {
+    const datasetId = refPrefixMap['IEV'];
+    if (datasetId) refs.push({ id: `https://glossarist.org/${datasetId}/concept/${m[2]}`, term: m[1].trim() });
+  }
+
+  for (const m of fullText.matchAll(/\{urn:iso:std:iso:(\d+):([^,}]+),([^,}]+)(?:,([^}]+))?\}/g)) {
+    const datasetId = urnStandardMap[m[1]];
+    if (datasetId) refs.push({ id: `https://glossarist.org/${datasetId}/concept/${m[2]}`, term: (m[4] || m[3]).trim() });
+  }
+
+  for (const m of fullText.matchAll(/\{\{urn:iso:std:iso:(\d+):([^,}]+),([^,}]+)(?:,([^}]+))?\}\}/g)) {
+    const datasetId = urnStandardMap[m[1]];
+    if (datasetId) refs.push({ id: `https://glossarist.org/${datasetId}/concept/${m[2]}`, term: (m[4] || m[3]).trim() });
+  }
+
+  const seen = new Set();
+  return refs.filter(r => {
+    if (seen.has(r.id)) return false;
+    seen.add(r.id);
+    return true;
+  });
+}
+
 const LANG_CODES = ['eng', 'ara', 'deu', 'fra', 'spa', 'ita', 'jpn', 'kor', 'pol', 'por', 'srp', 'swe', 'zho', 'rus', 'fin', 'dan', 'nld', 'msa', 'nob', 'nno', 'zho'];
 
-function yamlToJsonLd(conceptYaml, register) {
+function yamlToJsonLd(conceptYaml, register, refMaps) {
   const termid = String(conceptYaml.termid);
   const doc = {
     '@context': 'https://glossarist.org/ns/context.jsonld',
@@ -142,6 +205,11 @@ function yamlToJsonLd(conceptYaml, register) {
     }
     if (lc.references && lc.references.length > 0) {
       lDoc['gl:references'] = refsToJsonLd(lc.references);
+    } else if (refMaps) {
+      const inlineRefs = extractInlineRefs(lc, refMaps.refPrefixMap, refMaps.urnStandardMap);
+      if (inlineRefs.length > 0) {
+        lDoc['gl:references'] = refsToJsonLd(inlineRefs);
+      }
     }
 
     localizations[lang] = lDoc;
@@ -374,7 +442,7 @@ function processDataset(dir, register, opts) {
       if (!conceptYaml || !conceptYaml.termid) continue;
 
       const termid = String(conceptYaml.termid);
-      const jsonld = yamlToJsonLd(conceptYaml, register);
+      const jsonld = yamlToJsonLd(conceptYaml, register, refMaps);
       writeJson(path.join(conceptsDir, `${termid}.json`), jsonld);
 
       // Generate Turtle format
@@ -526,10 +594,36 @@ function processDataset(dir, register, opts) {
     languageStats: langStats,
     availableFormats,
     bulkFormats,
+    hasBibliography: opts.hasBibliography,
+    hasImages: opts.hasImages,
   };
   if (opts.languageOrder) manifest.languageOrder = opts.languageOrder;
   writeJson(path.join(DATA, register, 'manifest.json'), manifest);
 
+  // Copy bibliography.yaml → bibliography.json
+  const bibPath = path.join(ROOT, '.datasets', register, 'bibliography.yaml');
+  if (fs.existsSync(bibPath)) {
+    const bibData = readYaml(bibPath);
+    writeJson(path.join(DATA, register, 'bibliography.json'), bibData);
+    console.log(`  Copied bibliography (${Object.keys(bibData).length} entries)`);
+  }
+
+  // Copy images/
+  const imagesSrcDir = path.join(ROOT, '.datasets', register, 'images');
+  if (fs.existsSync(imagesSrcDir) && fs.statSync(imagesSrcDir).isDirectory()) {
+    const imagesDestDir = path.join(DATA, register, 'images');
+    fs.mkdirSync(imagesDestDir, { recursive: true });
+    let imgCount = 0;
+    for (const file of fs.readdirSync(imagesSrcDir)) {
+      const src = path.join(imagesSrcDir, file);
+      if (fs.statSync(src).isFile()) {
+        fs.copyFileSync(src, path.join(imagesDestDir, file));
+        imgCount++;
+      }
+    }
+    console.log(`  Copied ${imgCount} images`);
+  }
+
   console.log(`  Generated ${concepts.length} concepts, manifest, ${chunks.length} index chunks`);
   return concepts.length;
 }
@@ -538,6 +632,7 @@ function processDataset(dir, register, opts) {
 console.log('Generating Glossarist vocabulary browser data...\n');
 
 const { config } = loadSiteConfig();
+const refMaps = buildRefMaps(config);
 const counts = {};
 const registry = [];
 
@@ -571,6 +666,8 @@ for (let i = 0; i < config.datasets.length; i++) {
     color: ds.color || DS_PALETTE[i % DS_PALETTE.length],
     datasetUri: ds.uri,
     uriAliases: ds.uriAliases,
+    hasBibliography: fs.existsSync(path.join(ROOT, '.datasets', ds.id, 'bibliography.yaml')),
+    hasImages: fs.existsSync(path.join(ROOT, '.datasets', ds.id, 'images')),
   });
   registry.push({ id: ds.id, manifestUrl: `/data/${ds.id}/manifest.json` });
 }
@@ -824,6 +921,7 @@ writeJson(path.join(PUBLIC, 'site-config.json'), {
   email: config.email,
   pages: processedPages.length > 0 ? processedPages : undefined,
   contributors: config.contributors || undefined,
+  copyright: config.copyright || undefined,
 });
 console.log('Generated site-config.json');
 

package/src/__tests__/math.test.ts

@@ -63,6 +63,29 @@ describe('renderMath', () => {
     expect(result).toBe('a entity ref');
   });
 
+  it('uses display text from three-part URN refs', () => {
+    const result = renderMath('a {{urn:iso:std:iso:14812:3.1.1.6,person,Person}} ref');
+    expect(result).toBe('a Person ref');
+  });
+
+  it('resolves three-part URN refs with display text via xrefResolver', () => {
+    const resolver = (uri: string, term: string) => `[${term}→${uri}]`;
+    const result = renderMath(
+      '{{urn:iso:std:iso:14812:3.1.1.6,person,Person}}, object, event',
+      resolver,
+    );
+    expect(result).toBe('[Person→urn:iso:std:iso:14812:3.1.1.6], object, event');
+  });
+
+  it('resolves single-braced three-part URN refs', () => {
+    const resolver = (uri: string, term: string) => `[${term}→${uri}]`;
+    const result = renderMath(
+      '{urn:iso:std:iso:14812:3.5.3.4,user,users} are people',
+      resolver,
+    );
+    expect(result).toBe('[users→urn:iso:std:iso:14812:3.5.3.4] are people');
+  });
+
   it('strips remaining {{...}} to just the term', () => {
     const result = renderMath('see {{some term, unknown ref}}');
     expect(result).toBe('see some term');
@@ -106,6 +129,10 @@ describe('cleanContent', () => {
     expect(cleanContent('a {{urn:iso:std:iso:14812:3.1.1.1,entity}} ref')).toBe('a entity ref');
   });
 
+  it('strips three-part URN refs to the linked term (not display text)', () => {
+    expect(cleanContent('{{urn:iso:std:iso:14812:3.1.1.6,person,Person}}, object')).toBe('person, object');
+  });
+
   it('handles empty input', () => {
     expect(cleanContent('')).toBe('');
     expect(cleanContent(null as any)).toBe('');

package/src/components/AppFooter.vue

@@ -19,6 +19,7 @@ const socialLinks = computed(() => {
 });
 
 const footerNav = computed(() => config.value?.footerNav ?? []);
+const copyrightOwner = computed(() => config.value?.copyright || '');
 const ownerName = computed(() => config.value?.branding?.ownerName || config.value?.title || '');
 const ownerUrl = computed(() => config.value?.branding?.ownerUrl || '/');
 </script>
@@ -28,7 +29,10 @@ const ownerUrl = computed(() => config.value?.branding?.ownerUrl || '/');
     <div class="max-w-5xl mx-auto px-4 sm:px-6 lg:px-8 py-6">
       <div class="flex flex-col sm:flex-row items-center justify-between gap-4 text-sm text-ink-400">
         <div class="flex items-center gap-3">
-          <span v-if="ownerName">
+          <span v-if="copyrightOwner">
+            &copy; {{ new Date().getFullYear() }} {{ copyrightOwner }}
+          </span>
+          <span v-else-if="ownerName">
             &copy; {{ new Date().getFullYear() }}
             <a v-if="ownerUrl" :href="ownerUrl" target="_blank" rel="noopener" class="concept-link">{{ ownerName }}</a>
             <span v-else>{{ ownerName }}</span>

package/src/components/ConceptDetail.vue

@@ -4,11 +4,12 @@ import type { Manifest } from '../adapters/types';
 import { computed, ref, nextTick, watch } from 'vue';
 import { langName, langLabel } from '../utils/lang';
 import { renderMath, cleanContent } from '../utils/math';
-import type { XrefResolver } from '../utils/math';
+import type { RenderOptions } from '../utils/math';
 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 ConceptTimeline from './ConceptTimeline.vue';
 import FormatDownloads from './FormatDownloads.vue';
 
@@ -87,20 +88,28 @@ function escapeAttr(s: string) {
   return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
 
-const xrefResolver: XrefResolver = (uri, term) => {
-  const resolution = factory.resolve(uri, props.registerId);
-  if (resolution.type === 'internal') {
-    return `<a href="#" class="xref-link" data-register="${escapeAttr(resolution.registerId)}" data-concept="${escapeAttr(resolution.conceptId)}">${escapeAttr(term)}</a>`;
-  }
-  if (resolution.type === 'site') {
-    return `<a href="${escapeAttr(resolution.baseUrl)}/resolve/${escapeAttr(encodeURIComponent(uri))}" target="_blank" rel="noopener" class="xref-link xref-external">${escapeAttr(term)}</a>`;
-  }
-  if (resolution.type === 'url') {
-    return `<a href="${escapeAttr(resolution.url)}" target="_blank" rel="noopener" class="xref-link xref-external">${escapeAttr(term)}</a>`;
-  }
-  return escapeAttr(term);
+const { ensureBibLoaded, bibResolver, figResolver } = useRenderOptions(() => props.registerId);
+
+const renderOpts: RenderOptions = {
+  xrefResolver: (uri, term) => {
+    const resolution = factory.resolve(uri, props.registerId);
+    if (resolution.type === 'internal') {
+      return `<a href="#" class="xref-link" data-register="${escapeAttr(resolution.registerId)}" data-concept="${escapeAttr(resolution.conceptId)}">${escapeAttr(term)}</a>`;
+    }
+    if (resolution.type === 'site') {
+      return `<a href="${escapeAttr(resolution.baseUrl)}/resolve/${escapeAttr(encodeURIComponent(uri))}" target="_blank" rel="noopener" class="xref-link xref-external">${escapeAttr(term)}</a>`;
+    }
+    if (resolution.type === 'url') {
+      return `<a href="${escapeAttr(resolution.url)}" target="_blank" rel="noopener" class="xref-link xref-external">${escapeAttr(term)}</a>`;
+    }
+    return escapeAttr(term);
+  },
+  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;
@@ -415,14 +424,14 @@ function plainTruncate(html: string, max: number = 120): string {
 
               <!-- Definition -->
               <div v-if="lc.definition" class="p-4 rounded-lg bg-surface border-l-2" :style="{ borderLeftColor: getColor(manifest.id) }">
-                <div class="text-ink-800 leading-relaxed" v-html="renderMath(lc.definition, xrefResolver)"></div>
+                <div class="text-ink-800 leading-relaxed" v-html="renderMath(lc.definition, renderOpts)"></div>
               </div>
 
               <!-- Notes -->
               <div v-if="lc.notes.length" class="space-y-2">
                 <div v-for="(note, i) in lc.notes" :key="i" class="text-ink-600 text-sm leading-relaxed">
                   <span class="font-medium text-ink-400 text-xs uppercase tracking-wide">Note {{ i + 1 }}</span>
-                  <div class="mt-1" v-html="renderMath(note, xrefResolver)"></div>
+                  <div class="mt-1" v-html="renderMath(note, renderOpts)"></div>
                 </div>
               </div>
 
@@ -430,7 +439,7 @@ function plainTruncate(html: string, max: number = 120): string {
               <div v-if="lc.examples.length" class="space-y-2">
                 <div v-for="(ex, i) in lc.examples" :key="i" class="text-ink-600 text-sm leading-relaxed">
                   <span class="font-medium text-ink-400 text-xs uppercase tracking-wide">Example {{ i + 1 }}</span>
-                  <div class="mt-1" v-html="renderMath(ex, xrefResolver)"></div>
+                  <div class="mt-1" v-html="renderMath(ex, renderOpts)"></div>
                 </div>
               </div>
 

package/src/components/LanguageDetail.vue

@@ -3,7 +3,7 @@ import type { LocalizedConcept, Designation, ConceptSource } from '../adapters/t
 import { computed } from 'vue';
 import { langName, langLabel } from '../utils/lang';
 import { renderMath } from '../utils/math';
-import type { XrefResolver } from '../utils/math';
+import type { RenderOptions } from '../utils/math';
 import { useRouter } from 'vue-router';
 import { useVocabularyStore } from '../stores/vocabulary';
 import { getFactory } from '../adapters/factory';
@@ -82,8 +82,16 @@ function escapeAttr(s: string) {
 
 const factory = getFactory();
 
-const xrefResolver: XrefResolver = (uri, term) => {
-  return `<a href="#" class="xref-link" data-uri="${escapeAttr(uri)}">${escapeAttr(term)}</a>`;
+const renderOpts: RenderOptions = {
+  xrefResolver: (uri, term) => {
+    return `<a href="#" class="xref-link" data-uri="${escapeAttr(uri)}">${escapeAttr(term)}</a>`;
+  },
+  bibResolver: (refId, title) => {
+    return `<span class="bib-ref">${escapeAttr(title)}</span>`;
+  },
+  figResolver: (figId) => {
+    return `<span class="fig-ref">${escapeAttr(figId)}</span>`;
+  },
 };
 
 function handleContentClick(e: MouseEvent) {
@@ -145,7 +153,7 @@ function handleContentClick(e: MouseEvent) {
       <!-- Definition -->
       <div v-if="definition" class="card p-5">
         <div class="section-label">Definition</div>
-        <div class="text-ink-800 leading-relaxed mt-3" v-html="renderMath(definition, xrefResolver)"></div>
+        <div class="text-ink-800 leading-relaxed mt-3" v-html="renderMath(definition, renderOpts)"></div>
       </div>
 
       <!-- Notes -->
@@ -154,7 +162,7 @@ function handleContentClick(e: MouseEvent) {
         <div class="space-y-3 mt-3">
           <div v-for="(note, i) in notes" :key="i" class="text-ink-600 text-sm leading-relaxed">
             <span class="font-medium text-ink-400 text-xs uppercase tracking-wide">Note {{ i + 1 }}</span>
-            <div class="mt-1" v-html="renderMath(note, xrefResolver)"></div>
+            <div class="mt-1" v-html="renderMath(note, renderOpts)"></div>
           </div>
         </div>
       </div>
@@ -165,7 +173,7 @@ function handleContentClick(e: MouseEvent) {
         <div class="space-y-3 mt-3">
           <div v-for="(ex, i) in examples" :key="i" class="text-ink-600 text-sm leading-relaxed">
             <span class="font-medium text-ink-400 text-xs uppercase tracking-wide">Example {{ i + 1 }}</span>
-            <div class="mt-1" v-html="renderMath(ex, xrefResolver)"></div>
+            <div class="mt-1" v-html="renderMath(ex, renderOpts)"></div>
           </div>
         </div>
       </div>

package/src/composables/use-render-options.ts

@@ -0,0 +1,58 @@
+import { ref, watch } from 'vue';
+import type { RenderOptions, BibResolver, FigResolver } from '../utils/math';
+import { getFactory } from '../adapters/factory';
+
+interface BibEntry {
+  reference: string;
+  title?: string;
+  link?: string;
+}
+
+const bibCache = new Map<string, Record<string, BibEntry>>();
+
+async function loadBibliography(registerId: string): Promise<Record<string, BibEntry> | null> {
+  if (bibCache.has(registerId)) return bibCache.get(registerId)!;
+  try {
+    const resp = await fetch(`/data/${registerId}/bibliography.json`);
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    bibCache.set(registerId, data);
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+export function useRenderOptions(registerId: () => string) {
+  const bibData = ref<Record<string, BibEntry> | null>(null);
+
+  async function ensureBibLoaded() {
+    const id = registerId();
+    if (!id) return;
+    bibData.value = await loadBibliography(id);
+  }
+
+  const bibResolver: BibResolver = (refId, title) => {
+    const entry = bibData.value?.[refId];
+    if (!entry) {
+      return `<span class="bib-ref">${escapeAttr(title)}</span>`;
+    }
+    const display = title || entry.reference;
+    if (entry.link) {
+      return `<a href="${escapeAttr(entry.link)}" target="_blank" rel="noopener" class="bib-link" title="${escapeAttr(entry.title || '')}">${escapeAttr(display)}</a>`;
+    }
+    return `<span class="bib-ref" title="${escapeAttr(entry.title || '')}">${escapeAttr(display)}</span>`;
+  };
+
+  const figResolver: FigResolver = (figId) => {
+    const id = registerId();
+    const imgSrc = `/data/${id}/images/${figId}.png`;
+    return `<span class="fig-ref"><a href="${escapeAttr(imgSrc)}" target="_blank" rel="noopener">${escapeAttr(figId)}</a></span>`;
+  };
+
+  return { bibData, ensureBibLoaded, bibResolver, figResolver };
+}
+
+function escapeAttr(s: string) {
+  return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}

package/src/config/types.ts

@@ -155,4 +155,5 @@ export interface SiteConfig {
   email?: string;
   pages?: PageConfig[];
   contributors?: Contributor[];
+  copyright?: string;
 }

package/src/config/use-site-config.ts

@@ -30,6 +30,7 @@ export interface RuntimeSiteConfig {
   email?: string;
   pages?: PageConfig[];
   contributors?: { name: string; role?: string; organization?: string; url?: string; email?: string }[];
+  copyright?: string;
 }
 
 const siteConfig = ref<RuntimeSiteConfig | null>(null);

package/src/style.css

@@ -121,6 +121,18 @@
     font-weight: 500;
   }
 
+  .bib-link {
+    @apply text-ink-600 hover:text-ink-800 underline-offset-2 hover:underline transition-colors;
+  }
+
+  .bib-ref {
+    @apply text-ink-500 italic;
+  }
+
+  .fig-ref a {
+    @apply text-ink-600 hover:text-ink-800 underline-offset-2 hover:underline transition-colors;
+  }
+
   /* Concept definition lists */
   .concept-list {
     list-style: disc;

package/src/utils/math.ts

@@ -1,6 +1,14 @@
 import katex from 'katex';
 
 export type XrefResolver = (uri: string, term: string) => string;
+export type BibResolver = (refId: string, title: string) => string;
+export type FigResolver = (figId: string) => string;
+
+export interface RenderOptions {
+  xrefResolver?: XrefResolver;
+  bibResolver?: BibResolver;
+  figResolver?: FigResolver;
+}
 
 /**
  * Convert `* item` lines into <ul><li> blocks.
@@ -39,12 +47,16 @@ function convertLists(text: string): string {
 
 /**
  * Render stem:[...] math notation to KaTeX HTML.
- * Also handles cross-reference inline patterns (URN refs).
+ * Also handles cross-reference inline patterns (URN refs, bibliography, figures).
  */
-export function renderMath(text: string, xrefResolver?: XrefResolver): string {
+export function renderMath(text: string, xrefResolverOrOpts?: XrefResolver | RenderOptions): string {
   if (!text) return '';
   let result = text;
 
+  const opts: RenderOptions = typeof xrefResolverOrOpts === 'function'
+    ? { xrefResolver: xrefResolverOrOpts }
+    : (xrefResolverOrOpts ?? {});
+
   result = result.replace(/\*stem:\[([^\]]*)\]\*/g, (_, math) => {
     return renderKatexSpan(math, true);
   });
@@ -58,20 +70,38 @@ export function renderMath(text: string, xrefResolver?: XrefResolver): string {
   result = result.replace(/\*([^*]+)\*/g, '<em>$1</em>');
   result = result.replace(/~([^~]+)~/g, '<sub>$1</sub>');
 
-  // Handle URN inline refs: {{urn:...,term}} (double-braced)
-  result = result.replace(/\{\{(urn:[^,}]+),([^}]+)\}\}/g, (_, uri, term) => {
-    if (xrefResolver) {
-      return xrefResolver(uri, term.trim());
+  // Handle AsciiDoc bibliography xrefs: <<ref_XX,title>>
+  result = result.replace(/<<([^,>]+),([^>]+)>>/g, (_, refId, title) => {
+    if (opts.bibResolver) {
+      return opts.bibResolver(refId.trim(), title.trim());
+    }
+    return `<span class="bib-ref">${escapeHtml(title.trim())}</span>`;
+  });
+
+  // Handle AsciiDoc figure xrefs: <<fig_XX>>
+  result = result.replace(/<<(fig_[^>]+)>>/g, (_, figId) => {
+    if (opts.figResolver) {
+      return opts.figResolver(figId.trim());
+    }
+    return `<span class="fig-ref">${escapeHtml(figId.trim())}</span>`;
+  });
+
+  // Handle URN inline refs: {{urn:...,term[,displayText]}} (double-braced)
+  result = result.replace(/\{\{(urn:[^,}]+),([^,}]+)(?:,([^}]+))?\}\}/g, (_, uri, term, display) => {
+    const text = (display || term).trim();
+    if (opts.xrefResolver) {
+      return opts.xrefResolver(uri, text);
     }
-    return term.trim();
+    return text;
   });
 
-  // Handle URN inline refs: {urn:...,term} (single-braced)
-  result = result.replace(/\{(urn:[^,}]+),([^}]+)\}/g, (_, uri, term) => {
-    if (xrefResolver) {
-      return xrefResolver(uri, term.trim());
+  // Handle URN inline refs: {urn:...,term[,displayText]} (single-braced)
+  result = result.replace(/\{(urn:[^,}]+),([^,}]+)(?:,([^}]+))?\}/g, (_, uri, term, display) => {
+    const text = (display || term).trim();
+    if (opts.xrefResolver) {
+      return opts.xrefResolver(uri, text);
     }
-    return term.trim();
+    return text;
   });
 
   // Handle any remaining {{...}} refs (fallback: show term before comma)
@@ -111,7 +141,9 @@ export function cleanContent(text: string): string {
     .replace(/\*([^*]+)\*/g, '$1')
     .replace(/~([^~]+)~/g, '_$1')
     .replace(/\n[ \t]*\* /g, '; ')
-    .replace(/\{\{urn:[^,}]+,([^}]+)\}\}/g, '$1')
-    .replace(/\{urn:[^,}]+,([^}]+)\}/g, '$1')
+    .replace(/<<([^,>]+),([^>]+)>>/g, '$2')
+    .replace(/<<(fig_[^>]+)>>/g, '$1')
+    .replace(/\{\{urn:[^,}]+,([^,}]+)(?:,[^}]+)?\}\}/g, '$1')
+    .replace(/\{urn:[^,}]+,([^,}]+)(?:,[^}]+)?\}/g, '$1')
     .replace(/\{\{([^,}]+)(?:,\s*[^}]+)?\}\}/g, '$1');
 }