@glossarist/concept-browser 0.7.35 → 0.7.37

package/src/components/CitationDisplay.vue

@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import type { Citation } from 'glossarist';
+import type { CitationClassification, CiteResolution } from '../adapters/types';
 import { computed, ref } from 'vue';
 import { getFactory } from '../adapters/factory';
 import { useRouter } from 'vue-router';
@@ -14,22 +15,26 @@ const router = useRouter();
 const store = useVocabularyStore();
 const factory = getFactory();
 
-function resolveCitation(): { registerId: string; conceptId: string } | null {
-  const ref = props.citation.ref;
-  const locality = props.citation.locality;
-  if (!ref?.source || !locality?.referenceFrom) return null;
+// ── Single source of truth for citation resolution ────────────────────────
+// Both classification and navigation target come from the same resolveCite()
+// call, so they can never disagree.
 
-  const resolution = factory.resolveCitation(ref.source, locality.referenceFrom, props.registerId);
-  if (!resolution || resolution.type !== 'internal') return null;
+const citeResolution = computed<CiteResolution>(() =>
+  factory.resolver.resolveCite(props.citation, props.registerId),
+);
 
-  return { registerId: resolution.registerId, conceptId: resolution.conceptId };
-}
+const classification = computed<CitationClassification>(() =>
+  citeResolution.value.classification,
+);
+
+const resolvedTarget = computed(() => citeResolution.value.resolved);
 
-const resolvedTarget = computed(() => resolveCitation());
 const isCrossDataset = computed(() =>
   resolvedTarget.value != null && resolvedTarget.value.registerId !== props.registerId,
 );
 
+// ── Navigation ────────────────────────────────────────────────────────────
+
 async function navigateToCitation() {
   if (!resolvedTarget.value) return;
   const { registerId, conceptId } = resolvedTarget.value;
@@ -37,7 +42,37 @@ async function navigateToCitation() {
   router.push({ name: 'concept', params: { registerId, conceptId } });
 }
 
-// --- Hover preview ---
+// ── Wrapper element determined by classification ──────────────────────────
+// Internal → button (navigates to concept)
+// Self-contained with link → anchor (external link)
+// Everything else → span (plain text)
+
+const sourceTag = computed(() => {
+  if (classification.value === 'internal-citation') return 'button';
+  if (classification.value === 'self-contained-citation' && props.citation.link) return 'a';
+  return 'span';
+});
+
+const sourceAttrs = computed(() => {
+  if (sourceTag.value === 'button') {
+    return { class: 'concept-link font-medium inline-flex items-center gap-0.5' };
+  }
+  if (sourceTag.value === 'a') {
+    return { href: props.citation.link!, target: '_blank', rel: 'noopener', class: 'concept-link font-medium' };
+  }
+  return { class: 'font-medium' };
+});
+
+const sourceEvents = computed(() => {
+  if (sourceTag.value !== 'button') return {};
+  return {
+    onClick: navigateToCitation,
+    onMouseenter: schedulePreview,
+  };
+});
+
+// ── Hover preview ─────────────────────────────────────────────────────────
+
 const triggerEl = ref<HTMLElement | null>(null);
 const preview = ref<{ designation: string; definition: string } | null>(null);
 const previewVisible = ref(false);
@@ -90,39 +125,60 @@ function hidePreview() {
   if (previewTimer) { clearTimeout(previewTimer); previewTimer = null; }
   previewVisible.value = false;
 }
+
+// ── Locality formatting ───────────────────────────────────────────────────
+
+function formatLocality(loc: NonNullable<Citation['locality']>): string {
+  const parts: string[] = [];
+  const lType = (loc as unknown as Record<string, unknown>).type as string | null;
+  const from = (loc as unknown as Record<string, unknown>).referenceFrom ?? (loc as unknown as Record<string, unknown>).reference_from;
+  const to = (loc as unknown as Record<string, unknown>).referenceTo ?? (loc as unknown as Record<string, unknown>).reference_to;
+  if (lType) parts.push(`, ${lType}`);
+  if (from) parts.push(to ? ` ${from}–${to}` : ` ${from}`);
+  return parts.join('');
+}
 </script>
 
 <template>
   <span class="inline" @mouseleave="hidePreview">
-    <template v-if="citation.ref">
-      <button
-        v-if="resolvedTarget"
-        @click="navigateToCitation"
-        @mouseenter="schedulePreview"
-        class="concept-link font-medium inline-flex items-center gap-0.5"
+    <!-- Source reference: dynamic wrapper (button/a/span) -->
+    <template v-if="citation.ref?.source">
+      <component
+        :is="sourceTag"
+        v-bind="sourceAttrs"
+        v-on="sourceEvents"
       >
         {{ citation.ref.source }}
         <span v-if="isCrossDataset" class="text-[10px] opacity-60 leading-none">↗</span>
-      </button>
-      <span v-else-if="citation.ref.source" class="font-medium">{{ citation.ref.source }}</span>
+      </component>
       <span v-if="citation.ref.id"> {{ citation.ref.id }}</span>
       <span v-if="citation.ref.version" class="text-ink-400"> ({{ citation.ref.version }})</span>
     </template>
+
+    <!-- Locality: same formatting across all classifications -->
     <template v-if="citation.locality">
-      <button v-if="resolvedTarget" @click="navigateToCitation" @mouseenter="schedulePreview" class="concept-link">
-        <span v-if="citation.locality.type" class="text-ink-400">, {{ citation.locality.type }}</span>
-        <span v-if="citation.locality.referenceFrom" class="text-ink-400">
-          {{ citation.locality.referenceTo ? ` ${citation.locality.referenceFrom}–${citation.locality.referenceTo}` : ` ${citation.locality.referenceFrom}` }}
-        </span>
+      <button
+        v-if="classification === 'internal-citation'"
+        @click="navigateToCitation"
+        @mouseenter="schedulePreview"
+        class="concept-link"
+      >
+        {{ formatLocality(citation.locality) }}
       </button>
-      <template v-else>
-        <span v-if="citation.locality.type" class="text-ink-400">, {{ citation.locality.type }}</span>
-        <span v-if="citation.locality.referenceFrom" class="text-ink-400">
-          {{ citation.locality.referenceTo ? ` ${citation.locality.referenceFrom}–${citation.locality.referenceTo}` : ` ${citation.locality.referenceFrom}` }}
-        </span>
-      </template>
+      <span v-else class="text-ink-400">
+        {{ formatLocality(citation.locality) }}
+      </span>
     </template>
-    <a v-if="citation.link" :href="citation.link" target="_blank" rel="noopener" class="concept-link ml-1">[link]</a>
+
+    <!-- External link badge (only for non-self-contained citations that have a link) -->
+    <a
+      v-if="citation.link && classification !== 'self-contained-citation'"
+      :href="citation.link"
+      target="_blank"
+      rel="noopener"
+      class="concept-link ml-1"
+    >[link]</a>
+
     <span v-if="citation.original" class="text-xs text-ink-300 ml-1">(orig: {{ citation.original }})</span>
     <span v-if="resolvedTarget" class="text-[9px] text-ink-300 ml-1">→ {{ resolvedTarget.registerId }}/{{ resolvedTarget.conceptId }}</span>
 

package/src/components/ConceptDetail.vue

@@ -3,8 +3,8 @@ import type { Concept, LocalizedConcept, Designation } from 'glossarist';
 import type { Manifest, GraphEdge } from '../adapters/types';
 import { computed, ref, nextTick, watch } from 'vue';
 import { langName } from '../utils/lang';
-import { renderMath } from '../utils/math';
-import type { RenderOptions } from '../utils/math';
+import { renderContent } from '../utils/content-renderer';
+import type { RenderOptions } from '../utils/content-renderer';
 import { escapeAttr } from '../utils/escape';
 import { entryStatusColor, conceptStatusColor, conceptStatusLabel, conceptStatusDefinition, entryStatusLabel, entryStatusDefinition, getPreferredTerm } from '../utils/concept-helpers';
 import { sourceTypeInfo, sourceStatusInfo } from '../utils/designation-registry';
@@ -88,7 +88,7 @@ const engConcept = computed((): LocalizedConcept | null => {
 });
 
 const primaryTerm = computed(() => getPreferredTerm(engConcept.value, conceptId.value));
-const renderedPrimaryTerm = computed(() => renderMath(primaryTerm.value));
+const renderedPrimaryTerm = computed(() => renderContent(primaryTerm.value));
 
 const managedStatus = computed(() => props.concept.status);
 
@@ -118,7 +118,9 @@ const renderOpts = computed<RenderOptions>(() => ({
     return escapeAttr(term);
   },
   conceptRefResolver: (conceptId, term) => {
-    return `<a href="#" class="xref-link" data-register="${escapeAttr(props.registerId)}" data-concept="${escapeAttr(conceptId)}">${escapeAttr(term)}</a>`;
+    const adapter = factory.getAdapter(props.registerId);
+    const resolvedId = adapter?.lookupByDesignation(conceptId) ?? conceptId;
+    return `<a href="#" class="xref-link" data-register="${escapeAttr(props.registerId)}" data-concept="${escapeAttr(resolvedId)}">${escapeAttr(term)}</a>`;
   },
   bibResolver,
   figResolver,

package/src/components/LanguageDetail.vue

@@ -2,8 +2,8 @@
 import type { Concept, LocalizedConcept, Designation, Expression, Abbreviation as AbbreviationType } from 'glossarist';
 import { computed } from 'vue';
 import { langName, langLabel } from '../utils/lang';
-import { renderMath } from '../utils/math';
-import type { RenderOptions } from '../utils/math';
+import { renderContent } from '../utils/content-renderer';
+import type { RenderOptions } from '../utils/content-renderer';
 import { escapeAttr } from '../utils/escape';
 import { entryStatusColor } from '../utils/concept-helpers';
 import { designationTypeInfo, normativeStatusInfo, grammarBadges, pronunciationLabel, pronunciationTooltip } from '../utils/designation-registry';
@@ -115,7 +115,7 @@ function handleContentClick(e: MouseEvent) {
         <div class="section-label">{{ t('concept.designations') }}</div>
         <div class="space-y-2 mt-3">
           <div v-for="(d, i) in designations" :key="i" class="flex items-center gap-2 flex-wrap">
-            <span class="font-medium text-ink-800 text-lg" v-html="renderMath(d.designation)"></span>
+            <span class="font-medium text-ink-800 text-lg" v-html="renderContent(d.designation)"></span>
             <span class="badge text-[10px]" :class="designationTypeInfo(d).color">{{ designationTypeInfo(d).label }}</span>
             <span class="badge text-[10px]" :class="normativeStatusInfo(d.normativeStatus).color">{{ normativeStatusInfo(d.normativeStatus).label }}</span>
             <template v-if="d.type === 'expression' && (d as Expression).grammarInfo?.length">
@@ -142,7 +142,7 @@ function handleContentClick(e: MouseEvent) {
       <!-- Definition -->
       <div v-if="definition" class="card p-5">
         <div class="section-label">{{ t('concept.definition') }}</div>
-        <div class="text-ink-800 leading-relaxed mt-3" v-html="renderMath(definition, renderOpts)"></div>
+        <div class="text-ink-800 leading-relaxed mt-3" v-html="renderContent(definition, renderOpts)"></div>
       </div>
 
       <!-- Notes -->
@@ -151,7 +151,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">{{ t('concept.note') }} {{ i + 1 }}</span>
-            <div class="mt-1" v-html="renderMath(note, renderOpts)"></div>
+            <div class="mt-1" v-html="renderContent(note, renderOpts)"></div>
           </div>
         </div>
       </div>
@@ -162,7 +162,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">{{ t('concept.example') }} {{ i + 1 }}</span>
-            <div class="mt-1" v-html="renderMath(ex, renderOpts)"></div>
+            <div class="mt-1" v-html="renderContent(ex, renderOpts)"></div>
           </div>
         </div>
       </div>

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

@@ -1,8 +1,8 @@
 import { computed, ref, watch, type ComputedRef } from 'vue';
 import type { Concept, LocalizedConcept, ConceptSource, Designation } from 'glossarist';
 import type { Manifest } from '../adapters/types';
-import type { RenderOptions } from '../utils/math';
-import { renderMath, cleanContent } from '../utils/math';
+import type { RenderOptions } from '../utils/content-renderer';
+import { renderContent, cleanContent } from '../utils/content-renderer';
 import { getAnnotations } from '../adapters/model-bridge';
 import { getPreferredTerm, entryStatusColor, entryStatusLabel, entryStatusDefinition } from '../utils/concept-helpers';
 import { sortLanguages } from '../utils/lang';
@@ -68,18 +68,18 @@ export function useConceptContent(
       result.push({
         lang,
         lc,
-        renderedTerm: renderMath(getPreferredTerm(lc, '')),
+        renderedTerm: renderContent(getPreferredTerm(lc, '')),
         definition,
-        renderedDefinition: renderMath(definition, opts),
+        renderedDefinition: renderContent(definition, opts),
         annotations,
-        renderedAnnotations: annotations.map((a: string) => renderMath(a, opts)),
+        renderedAnnotations: annotations.map((a: string) => renderContent(a, opts)),
         notes,
-        renderedNotes: notes.map(n => renderMath(n, opts)),
+        renderedNotes: notes.map(n => renderContent(n, opts)),
         examples,
-        renderedExamples: examples.map(e => renderMath(e, opts)),
+        renderedExamples: examples.map(e => renderContent(e, opts)),
         sources: lc.sources,
         designations: lc.terms,
-        renderedDesignations: new Map(lc.terms.map(d => [d.designation, renderMath(d.designation)])),
+        renderedDesignations: new Map(lc.terms.map(d => [d.designation, renderContent(d.designation)])),
         entryStatus: lc.entryStatus ?? '',
         classification: lc.classification,
         reviewType: lc.reviewType,

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

@@ -1,5 +1,5 @@
 import { ref, watch } from 'vue';
-import type { RenderOptions, BibResolver, FigResolver } from '../utils/math';
+import type { RenderOptions, BibResolver, FigResolver } from '../utils/content-renderer';
 import { getFactory } from '../adapters/factory';
 import { escapeAttr } from '../utils/escape';
 

package/src/graph/GraphEngine.ts

@@ -1,5 +1,5 @@
 import type { GraphNode, GraphEdge } from '../adapters/types';
-import { ReferenceResolver } from '../adapters/ReferenceResolver';
+import { UriRouter } from '../adapters/UriRouter';
 
 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 = ReferenceResolver.parseUri(edge.target);
+    const parsed = UriRouter.parseUri(edge.target);
     if (!this.nodes.has(edge.source)) {
-      const sourceParsed = ReferenceResolver.parseUri(edge.source);
+      const sourceParsed = UriRouter.parseUri(edge.source);
       this.nodes.set(edge.source, {
         uri: edge.source,
         register: sourceParsed?.registerId ?? edge.register,

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 { ReferenceResolver } from '../adapters/ReferenceResolver';
+import { UriRouter } from '../adapters/UriRouter';
 import { deduplicateSearchHits } from '../utils/search';
 
 export const useVocabularyStore = defineStore('vocabulary', () => {
@@ -159,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 = ReferenceResolver.parseUri(edge.target);
+        const parsed = UriRouter.parseUri(edge.target);
         if (parsed?.registerId && parsed.registerId !== registerId) {
           targetRegisters.add(parsed.registerId);
         }

package/src/utils/content-renderer.ts

@@ -0,0 +1,312 @@
+/**
+ * Content renderer: transforms Glossarist inline content notation to HTML.
+ *
+ * Handles ALL inline rendering — mentions, cross-references, citations,
+ * math placeholders, tables, lists, and text formatting. This is the single
+ * source of truth for content rendering in the browser.
+ *
+ * Math-specific helpers (replaceBracketed, mathPlaceholder) are internal.
+ * The v-math directive upgrades the placeholders to KaTeX at runtime.
+ */
+import { escapeHtml, escapeAttr } from './escape';
+import { parseMention } from 'glossarist';
+
+// ── Resolver types ────────────────────────────────────────────────────────
+
+export type XrefResolver = (uri: string, term: string) => string;
+export type BibResolver = (refId: string, title: string) => string;
+export type FigResolver = (figId: string) => string;
+export type CiteResolver = (key: string, label: string | null) => string;
+export type ConceptRefResolver = (conceptId: string, term: string) => string;
+export type UrnRefResolver = (uri: string, term: string) => string;
+
+export interface RenderOptions {
+  xrefResolver?: XrefResolver;
+  bibResolver?: BibResolver;
+  figResolver?: FigResolver;
+  conceptRefResolver?: ConceptRefResolver;
+  citeResolver?: CiteResolver;
+  urnRefResolver?: UrnRefResolver;
+}
+
+// ── Math placeholders ────────────────────────────────────────────────────
+
+function replaceBracketed(text: string, prefix: string, handler: (content: string, bold: boolean) => string): string {
+  let result = '';
+  let i = 0;
+  const boldPrefix = '*' + prefix;
+  while (i < text.length) {
+    if (text.startsWith(boldPrefix + '[', i)) {
+      i += boldPrefix.length + 1;
+      let j = i;
+      let d = 1;
+      while (j < text.length && d > 0) {
+        if (text[j] === '[') d++;
+        else if (text[j] === ']') d--;
+        j++;
+      }
+      const content = text.slice(i, j - 1);
+      let end = j;
+      if (end < text.length && text[end] === '*') end++;
+      result += handler(content, true);
+      i = end;
+    } else if (text.startsWith(prefix + '[', i)) {
+      i += prefix.length + 1;
+      let j = i;
+      let d = 1;
+      while (j < text.length && d > 0) {
+        if (text[j] === '[') d++;
+        else if (text[j] === ']') d--;
+        j++;
+      }
+      const content = text.slice(i, j - 1);
+      result += handler(content, false);
+      i = j;
+    } else {
+      result += text[i];
+      i++;
+    }
+  }
+  return result;
+}
+
+function mathPlaceholder(expr: string, format: string, bold: boolean): string {
+  return `<span class="math-pending${bold ? ' math-bold' : ''}" data-expr="${escapeAttr(expr)}" data-format="${format}">${escapeAttr(expr)}</span>`;
+}
+
+// ── Block transforms ─────────────────────────────────────────────────────
+
+function convertAsciiDocTables(text: string): string {
+  return text.replace(/\n?\|===\n([\s\S]*?)\n\|===/g, (_: string, body: string) => {
+    const rows: string[] = body.split('\n').filter((line: string) => line.trim() !== '');
+    if (!rows.length) return '';
+
+    const parsedRows: string[][] = rows.map((row: string) => {
+      const cellText = row.replace(/^\s*\|/, '').trim();
+      const cells = cellText.split(/\s*\|\s*/).map((c: string) => c.trim()).filter((c: string) => c !== '');
+      return cells;
+    }).filter((r: string[]) => r.length > 0);
+
+    if (!parsedRows.length) return '';
+
+    const maxCols = Math.max(...parsedRows.map((r: string[]) => r.length));
+    const normalized = parsedRows.map((r: string[]) => {
+      while (r.length < maxCols) r.push('');
+      return r;
+    });
+
+    const thead = normalized[0].map((c: string) => `<th>${escapeHtml(c)}</th>`).join('');
+    const tbody = normalized.slice(1).map((r: string[]) =>
+      `<tr>${r.map((c: string) => `<td>${escapeHtml(c)}</td>`).join('')}</tr>`
+    ).join('');
+
+    return `\n<table class="concept-table"><thead><tr>${thead}</tr></thead><tbody>${tbody}</tbody></table>`;
+  });
+}
+
+function convertLists(text: string): string {
+  let result = text.replace(/(?:^|\n)((?:[ \t]*\* [^\n]+)(?:\n[ \t]*\* [^\n]+)*)/g, (_, block) => {
+    if (/^\*stem:\[/.test(block.trimStart())) return _;
+    const items: string[] = [];
+    const re = /[ \t]*\* ([^\n]+)/g;
+    let m;
+    while ((m = re.exec(block)) !== null) {
+      items.push(m[1].trim());
+    }
+    if (!items.length) return _;
+    const lis = items.map(item => `<li>${item}</li>`).join('');
+    return `\n<ul class="concept-list">${lis}</ul>`;
+  });
+
+  result = result.replace(/(?:^|\n)((?:[ \t]*\d+[).][ \t]+[^\n]+)(?:\n[ \t]*\d+[).][ \t]+[^\n]+)*)/g, (_, block) => {
+    const items: string[] = [];
+    const re = /[ \t]*\d+[).][ \t]+([^\n]+)/g;
+    let m;
+    while ((m = re.exec(block)) !== null) {
+      items.push(m[1].trim());
+    }
+    if (!items.length) return _;
+    const lis = items.map(item => `<li>${item}</li>`).join('');
+    return `\n<ol class="concept-list concept-list-ordered">${lis}</ol>`;
+  });
+
+  return result;
+}
+
+// ── Inline reference resolution ──────────────────────────────────────────
+
+function resolveBibRefs(text: string, opts: RenderOptions): string {
+  return text.replace(/<<([^,>]+),([^>]+)>>/g, (_, refId, title) => {
+    if (opts.bibResolver) {
+      return opts.bibResolver(refId.trim(), title.trim());
+    }
+    return `<span class="bib-ref">${escapeHtml(title.trim())}</span>`;
+  });
+}
+
+function resolveFigRefs(text: string, opts: RenderOptions): string {
+  return text.replace(/<<(fig_[^>]+)>>/g, (_, figId) => {
+    if (opts.figResolver) {
+      return opts.figResolver(figId.trim());
+    }
+    return `<span class="fig-ref">${escapeHtml(figId.trim())}</span>`;
+  });
+}
+
+function resolveUrnRefs(text: string, opts: RenderOptions): string {
+  // Double-brace URN refs: {{urn:...,term}} or {{urn:...,term,display}}
+  // Note: glossarist ≥ 0.3.7 parseMention handles these as 'urn-ref', but we
+  // keep this handler for when parseMention returns 'unresolved' (glossarist < 0.3.7)
+  let result = text.replace(/\{\{(urn:[^,}]+),([^,}]+)(?:,([^}]+))?\}\}/g, (_, uri, term, display) => {
+    const t = (display || term).trim();
+    if (opts.xrefResolver) {
+      return opts.xrefResolver(uri, t);
+    }
+    return t;
+  });
+
+  // Single-brace URN refs: {urn:...,term} or {urn:...,term,display}
+  result = result.replace(/\{(urn:[^,}]+),([^,}]+)(?:,([^}]+))?\}/g, (_, uri, term, display) => {
+    const t = (display || term).trim();
+    if (opts.xrefResolver) {
+      return opts.xrefResolver(uri, t);
+    }
+    return t;
+  });
+
+  return result;
+}
+
+function resolveMentions(text: string, opts: RenderOptions): string {
+  // Single-pass {{...}} mention dispatcher via parseMention (SSOT)
+  return text.replace(/\{\{([^{}]+?)\}\}/g, (_orig, body) => {
+    const parsed = parseMention(body);
+
+    // cite:key[,render term] — bibliography citation
+    if (parsed.kind === 'cite-ref') {
+      const key = parsed.key!;
+      const label = parsed.label ?? null;
+      if (opts.citeResolver) return opts.citeResolver(key, label);
+      return `<span class="bib-ref">${escapeHtml(label ?? key)}</span>`;
+    }
+
+    // urn:...[,render term] — URN cross-reference (glossarist ≥ 0.3.7)
+    const anyParsed = parsed as Record<string, unknown>;
+    if ((anyParsed.kind as string) === 'urn-ref') {
+      const uri = anyParsed.uri as string;
+      const label = (anyParsed.label as string) ?? uri;
+      if (opts.urnRefResolver) return opts.urnRefResolver(uri, label);
+      if (opts.xrefResolver) return opts.xrefResolver(uri, label);
+      return escapeHtml(label);
+    }
+
+    // numeric_id[,render term] — local concept ID
+    if (parsed.kind === 'numeric') {
+      const id = parsed.id!;
+      const label = parsed.label;
+      if (label && opts.conceptRefResolver) {
+        return opts.conceptRefResolver(id, label);
+      }
+      return `<span class="gl-mention">${escapeHtml(id)}</span>`;
+    }
+
+    // designation[,render term] — designation matching (glossarist ≥ 0.3.7)
+    if ((anyParsed.kind as string) === 'designation') {
+      const designation = anyParsed.id as string;
+      const label = (anyParsed.label as string) ?? designation;
+      if (opts.conceptRefResolver) {
+        return opts.conceptRefResolver(designation, label);
+      }
+      return escapeHtml(label);
+    }
+
+    // Fallback for unresolved: handle two-arg form or render as plain text
+    // This handles cases where parseMention doesn't recognize the kind
+    // (e.g. glossarist < 0.3.7 before urn-ref/designation kinds were added)
+    const commaIdx = body.indexOf(',');
+    if (commaIdx > 0) {
+      const id = body.slice(0, commaIdx).trim();
+      const display = body.slice(commaIdx + 1).trim();
+      if (opts.conceptRefResolver) return opts.conceptRefResolver(id, display);
+      return escapeHtml(display);
+    }
+
+    return `<span class="gl-mention">${escapeHtml(body.trim())}</span>`;
+  });
+}
+
+// ── Public API ───────────────────────────────────────────────────────────
+
+/**
+ * Render Glossarist inline content notation to HTML.
+ *
+ * Pipeline stages (in order):
+ * 1. Math placeholders (stem:, latexmath:)
+ * 2. AsciiDoc tables
+ * 3. Bullet and numbered lists
+ * 4. Text formatting (bold, italic, subscript)
+ * 5. Bibliography cross-references (<<ref,title>>)
+ * 6. Figure references (<<fig_...>>)
+ * 7. Single-brace URN inline references ({urn:...})
+ * 8. Mention dispatcher via parseMention (cite-ref, urn-ref, numeric, designation)
+ */
+export function renderContent(text: string, xrefResolverOrOpts?: XrefResolver | RenderOptions): string {
+  if (!text) return '';
+  let result = text;
+
+  const opts: RenderOptions = typeof xrefResolverOrOpts === 'function'
+    ? { xrefResolver: xrefResolverOrOpts }
+    : (xrefResolverOrOpts ?? {});
+
+  // Stage 1: Math expressions → placeholders for v-math directive
+  result = replaceBracketed(result, 'stem:', (expr, bold) => mathPlaceholder(expr, 'asciimath', bold));
+  result = replaceBracketed(result, 'latexmath:', (expr, bold) => mathPlaceholder(expr, 'latex', bold));
+
+  // Stage 2: Block structures
+  result = convertAsciiDocTables(result);
+  result = convertLists(result);
+
+  // Stage 3: Inline formatting
+  result = result.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
+  result = result.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '<em>$1</em>');
+  result = result.replace(/~([^~]+)~/g, '<sub>$1</sub>');
+
+  // Stage 4: Reference resolution
+  result = resolveBibRefs(result, opts);
+  result = resolveFigRefs(result, opts);
+  result = resolveUrnRefs(result, opts);
+
+  // Stage 5: Mention dispatcher (parseMention SSOT)
+  result = resolveMentions(result, opts);
+
+  return result;
+}
+
+/**
+ * Strip all inline notation to produce plain text.
+ * Used for search indexing, previews, and accessibility.
+ */
+export function cleanContent(text: string): string {
+  if (!text) return '';
+  let result = text
+    .replace(/<[^>]+>/g, '')
+    .replace(/\*\*([^*]+)\*\*/g, '$1')
+    .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '$1')
+    .replace(/~([^~]+)~/g, '_$1')
+    .replace(/\n[ \t]*\* /g, '; ')
+    .replace(/<<([^,>]+),([^>]+)>>/g, '$2')
+    .replace(/<<(fig_[^>]+)>>/g, '$1')
+    // URN refs — show render term (second part for two-arg, third part for three-arg)
+    .replace(/\{\{urn:[^,}]+,([^,}]+),([^}]+)\}\}/g, '$1')  // three-arg: {{urn:...,term,display}} → term
+    .replace(/\{\{urn:[^,}]+(?:,([^}]+))?\}\}/g, (_, label) => label ? label.trim() : '')  // two-arg or bare
+    .replace(/\{urn:[^,}]+,([^,}]+)(?:,[^}]+)?\}/g, '$1')
+    // Cite refs — show render term (or empty if bare)
+    .replace(/\{\{cite:[^,}]+(?:,([^}]+))?\}\}/g, (_, label) => label ? label.trim() : '')
+    // Two-arg mentions: show render term (second part)
+    .replace(/\{\{([^,}]+),\s*([^}]+)\}\}/g, '$2')
+    // One-arg mentions: show the identifier
+    .replace(/\{\{([^,}]+)\}\}/g, '$1')
+    .replace(/(?:\*?)stem:\[([^\]]*)\]/g, '$1')
+    .replace(/(?:\*?)latexmath:\[([^\]]*)\]/g, '$1');
+  return result;
+}

package/src/utils/markdown-lite.ts

@@ -1,3 +1,5 @@
+import { escapeHtml } from './escape';
+
 const INLINE_PATTERNS: [RegExp, (m: RegExpMatchArray) => string][] = [
   [/\*\*(.+?)\*\*/g, m => `<strong>${m[1]}</strong>`],
   [/(?<!\*)\*([^*]+?)\*(?!\*)/g, m => `<em>${m[1]}</em>`],
@@ -118,5 +120,3 @@ export function renderMarkdown(input: string): string {
 
   return blocks.join('\n');
 }
-
-import { escapeHtml } from './escape';