@glossarist/concept-browser 0.7.50 → 0.7.52

package/src/components/concept-rdf/sections-builder.ts

@@ -0,0 +1,62 @@
+import type { RdfGraph, RdfResource, RdfTerm } from './rdf-graph';
+
+export interface PropValue {
+  predicate: string;
+  values: string[];
+  nested?: boolean;
+}
+
+export interface ClassInstance {
+  classId: string;
+  classLabel: string;
+  label: string;
+  props: PropValue[];
+}
+
+export function buildSections(graph: RdfGraph): ClassInstance[] {
+  const out: ClassInstance[] = [];
+  for (const r of graph.resources()) {
+    out.push(resourceToSection(r));
+  }
+  return out;
+}
+
+function resourceToSection(r: RdfResource): ClassInstance {
+  const props: PropValue[] = [];
+  const seen = new Set<string>();
+
+  for (const t of r.triples) {
+    const value = formatTerm(t.object);
+    if (!value) continue;
+    const isNested = t.object.kind === 'blank';
+    const key = `${t.predicate}#${isNested ? 'n' : 'f'}#${value}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const prop: PropValue = {
+      predicate: t.predicate,
+      values: [value],
+    };
+    if (isNested) prop.nested = true;
+    props.push(prop);
+  }
+
+  return {
+    classId: r.classId,
+    classLabel: r.classLabel,
+    label: r.label,
+    props,
+  };
+}
+
+export function formatTerm(term: RdfTerm): string {
+  switch (term.kind) {
+    case 'iri':
+      return term.value;
+    case 'literal':
+      return term.value;
+    case 'blank': {
+      const parts = term.triples.map(t => `${t.predicate}: ${formatTerm(t.object)}`);
+      return parts.join('; ');
+    }
+  }
+}

package/src/components/concept-rdf/table-formula-emitter.ts

@@ -0,0 +1,101 @@
+import { GLOSS, DCTERMS, RDF, XSD } from './predicates';
+import { RdfGraph, lit, iri, blank, triple } from './rdf-graph';
+import type { RdfTriple } from './rdf-graph';
+
+export interface FormulaInput {
+  readonly registerId: string;
+  readonly formulaId: string;
+  readonly expression: string;
+  readonly latexForm?: string;
+  readonly description?: string;
+  readonly lang?: string;
+  readonly sourceIri?: string;
+  readonly baseUri?: string;
+}
+
+export interface TableHeaderCell {
+  readonly value: string;
+  readonly lang?: string;
+}
+
+export interface TableRow {
+  readonly cells: readonly string[];
+}
+
+export interface TableInput {
+  readonly registerId: string;
+  readonly tableId: string;
+  readonly title?: string;
+  readonly caption?: string;
+  readonly headers?: readonly TableHeaderCell[];
+  readonly rows?: readonly TableRow[];
+  readonly markup?: string;
+  readonly markupFormat?: string;
+  readonly lang?: string;
+  readonly baseUri?: string;
+}
+
+function base(input: { baseUri?: string }): string {
+  return input.baseUri ?? 'https://glossarist.org';
+}
+
+export function formulaIri(input: FormulaInput): string {
+  return `${base(input)}/${input.registerId}/formula/${input.formulaId}`;
+}
+
+export function tableIri(input: TableInput): string {
+  return `${base(input)}/${input.registerId}/table/${input.tableId}`;
+}
+
+export function emitFormulaGraph(input: FormulaInput): RdfGraph {
+  const graph = new RdfGraph();
+  const iriStr = formulaIri(input);
+  const w = graph.declare(iriStr, {
+    types: [GLOSS.Formula],
+    label: input.expression,
+    classLabel: 'Formula',
+    classId: GLOSS.Formula,
+  });
+  w.literal(GLOSS.expression, input.expression);
+  if (input.latexForm) w.literal(GLOSS.latexForm, input.latexForm);
+  if (input.description) w.literal(DCTERMS.description, input.description, { lang: input.lang });
+  if (input.sourceIri) w.iri('prov:wasDerivedFrom', input.sourceIri);
+  return graph;
+}
+
+export function emitTableGraph(input: TableInput): RdfGraph {
+  const graph = new RdfGraph();
+  const iriStr = tableIri(input);
+  const w = graph.declare(iriStr, {
+    types: [GLOSS.Table],
+    label: input.title ?? input.caption ?? input.tableId,
+    classLabel: 'Table',
+    classId: GLOSS.Table,
+  });
+
+  if (input.title) w.literal(DCTERMS.title, input.title, { lang: input.lang });
+  if (input.caption) w.literal(GLOSS.caption, input.caption, { lang: input.lang });
+
+  if (input.markup != null) {
+    const contentTriples: RdfTriple[] = [
+      triple(RDF.type, iri('gloss:MarkupTable')),
+      triple(GLOSS.content, lit(input.markup)),
+    ];
+    if (input.markupFormat) contentTriples.push(triple(DCTERMS.format, lit(input.markupFormat)));
+    w.blank(GLOSS.content, contentTriples);
+  } else if (input.headers && input.headers.length > 0) {
+    const contentTriples: RdfTriple[] = [
+      triple(RDF.type, iri('gloss:StructuredTable')),
+    ];
+    for (const h of input.headers) {
+      contentTriples.push(triple(GLOSS.hasHeader, lit(h.value, { lang: h.lang ?? input.lang })));
+    }
+    for (const row of input.rows ?? []) {
+      const rowTriples = row.cells.map(c => triple(GLOSS.content, lit(c)));
+      contentTriples.push(triple(GLOSS.hasRow, blank(...rowTriples)));
+    }
+    w.blank(GLOSS.content, contentTriples);
+  }
+
+  return graph;
+}

package/src/components/concept-rdf/turtle-writer.ts

@@ -0,0 +1,116 @@
+import { RDF_PREFIXES } from './rdf-prefixes';
+import type { RdfGraph, RdfResource, RdfTerm, RdfTriple } from './rdf-graph';
+
+const INDENT = '  ';
+
+const ABSOLUTE_SCHEMES = new Set(['http', 'https', 'urn', 'file', 'mailto', 'ftp']);
+
+function isPrefixedName(s: string): boolean {
+  const colonIdx = s.indexOf(':');
+  if (colonIdx < 1) return false;
+  const prefix = s.slice(0, colonIdx);
+  if (!/^[A-Za-z][A-Za-z0-9._-]*$/.test(prefix)) return false;
+  if (ABSOLUTE_SCHEMES.has(prefix)) return false;
+  const local = s.slice(colonIdx + 1);
+  return !local.startsWith('//');
+}
+
+function formatIri(value: string): string {
+  if (!isPrefixedName(value)) return `<${value}>`;
+  const colonIdx = value.indexOf(':');
+  const prefix = value.slice(0, colonIdx + 1);
+  const local = value.slice(colonIdx + 1);
+  const escaped = local.replace(/([/])/g, '\\$1');
+  return prefix + escaped;
+}
+
+export function writeTurtle(graph: RdfGraph): string {
+  const lines: string[] = [];
+
+  for (const p of RDF_PREFIXES) {
+    lines.push(`@prefix ${p.prefix}: <${p.iri}> .`);
+  }
+
+  let first = true;
+  for (const r of graph.resources()) {
+    if (first) {
+      lines.push('');
+      first = false;
+    } else {
+      lines.push('');
+    }
+    writeResource(lines, r);
+  }
+
+  return lines.join('\n');
+}
+
+function writeResource(lines: string[], r: RdfResource): void {
+  const subjectForm = formatSubject(r.subject);
+
+  if (r.types.length === 0 && r.triples.length === 0) {
+    lines.push(`${subjectForm} .`);
+    return;
+  }
+
+  if (r.types.length === 0) {
+    const [first, ...rest] = r.triples;
+    lines.push(`${subjectForm} ${first.predicate} ${formatObject(first.object)} ;`);
+    for (const t of rest) {
+      lines.push(`${INDENT}${t.predicate} ${formatObject(t.object)} ;`);
+    }
+    const last = lines.length - 1;
+    lines[last] = lines[last].replace(/ ;$/, ' .');
+    return;
+  }
+
+  const head = `${subjectForm} a ${r.types.join(', ')}`;
+  if (r.triples.length === 0) {
+    lines.push(`${head} .`);
+    return;
+  }
+  lines.push(`${head} ;`);
+  for (const t of r.triples) {
+    lines.push(`${INDENT}${t.predicate} ${formatObject(t.object)} ;`);
+  }
+  const last = lines.length - 1;
+  lines[last] = lines[last].replace(/ ;$/, ' .');
+}
+
+function formatSubject(subject: string): string {
+  return formatIri(subject);
+}
+
+function formatObject(term: RdfTerm): string {
+  switch (term.kind) {
+    case 'iri':
+      return formatIri(term.value);
+    case 'literal':
+      return formatLiteral(term.value, term.lang, term.datatype);
+    case 'blank':
+      return formatBlankNode(term.triples);
+  }
+}
+
+function formatLiteral(value: string, lang?: string, datatype?: string): string {
+  const escaped = escapeLiteral(value);
+  let s = `"${escaped}"`;
+  if (lang) s += `@${lang}`;
+  else if (datatype) s += `^^${datatype}`;
+  return s;
+}
+
+function formatBlankNode(triples: readonly RdfTriple[]): string {
+  if (triples.length === 0) return '[]';
+  const parts = triples.map(t => `${t.predicate} ${formatObject(t.object)}`);
+  return `[ ${parts.join(' ; ')} ]`;
+}
+
+function escapeLiteral(s: string): string {
+  return s
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t');
+}

package/src/components/concept-rdf/use-rdf-document.ts

@@ -0,0 +1,72 @@
+import type { ComputedRef } from 'vue';
+import { computed } from 'vue';
+import type { Concept } from 'glossarist';
+import { getClass } from '../../adapters/ontology-schema';
+import { ConceptIdentity } from '../../adapters/concept-identity';
+import { emitConceptGraph } from './concept-emitter';
+import { writeTurtle } from './turtle-writer';
+import { writeJsonLd } from './jsonld-writer';
+import { buildSections } from './sections-builder';
+import type { ClassInstance, PropValue } from './sections-builder';
+import { decorateWithProvenance, runtimeProvenance } from './provenance';
+
+export type { ClassInstance, PropValue } from './sections-builder';
+
+export interface RdfDocument {
+  sections: ComputedRef<ClassInstance[]>;
+  turtle: ComputedRef<string>;
+  jsonld: ComputedRef<string>;
+  typeChain: ComputedRef<string[]>;
+}
+
+export interface UseRdfDocumentOptions {
+  readonly lazy?: boolean;
+}
+
+const SERIALIZER_VERSION =
+  typeof __CONCEPT_BROWSER_VERSION__ !== 'undefined'
+    ? __CONCEPT_BROWSER_VERSION__
+    : 'dev';
+
+export function useRdfDocument(
+  getConcept: () => Concept,
+  getConceptUri: () => string,
+  _options: UseRdfDocumentOptions = {},
+): RdfDocument {
+  const identity = computed(() => {
+    const concept = getConcept();
+    const uri = getConceptUri();
+    if (ConceptIdentity.isConceptUri(uri)) {
+      const parsed = ConceptIdentity.fromUri(uri);
+      if (parsed.localId === concept.id) return parsed;
+    }
+    return new ConceptIdentity(concept.id, '', '');
+  });
+
+  const safeUri = computed(() => {
+    const uri = getConceptUri();
+    return uri || identity.value.uri;
+  });
+
+  const emission = computed(() => {
+    const result = emitConceptGraph(getConcept(), safeUri.value);
+    decorateWithProvenance(
+      result.graph,
+      safeUri.value,
+      runtimeProvenance(SERIALIZER_VERSION, safeUri.value),
+    );
+    return result;
+  });
+
+  const sections = computed(() => buildSections(emission.value.graph));
+  const turtle = computed(() => writeTurtle(emission.value.graph));
+  const jsonld = computed(() => writeJsonLd(emission.value.graph));
+
+  const typeChain = computed(() => {
+    const conceptCls = getClass('gloss:Concept');
+    if (!conceptCls) return ['owl:Thing', 'skos:Concept', 'gloss:Concept'];
+    return ['owl:Thing', ...conceptCls.ancestors, 'gloss:Concept'];
+  });
+
+  return { sections, turtle, jsonld, typeChain };
+}

package/src/components/concept-rdf/version-emitter.ts

@@ -0,0 +1,65 @@
+import { PROV, DCTERMS, XSD } from './predicates';
+import { RdfGraph, lit, iri, triple } from './rdf-graph';
+
+export interface DatasetVersionInput {
+  readonly registerId: string;
+  readonly version: string;
+  readonly versionIri: string;
+  readonly datasetIri: string;
+  readonly generatedAt: string;
+  readonly previousVersionIri?: string;
+  readonly changeSummary?: string;
+  readonly associatedAgentIri?: string;
+}
+
+export function emitVersionGraph(input: DatasetVersionInput): RdfGraph {
+  const graph = new RdfGraph();
+  const w = graph.declare(input.versionIri, {
+    types: [PROV.Entity],
+    label: `${input.registerId} version ${input.version}`,
+    classLabel: 'Version',
+    classId: PROV.Entity,
+  });
+  w.literal(DCTERMS.isVersionOf, input.datasetIri);
+  if (input.previousVersionIri) {
+    w.iri(PROV.wasRevisionOf, input.previousVersionIri);
+  }
+  w.literal(PROV.generatedAtTime, input.generatedAt, { datatype: XSD.dateTime });
+  if (input.changeSummary) w.literal(DCTERMS.description, input.changeSummary);
+  if (input.associatedAgentIri) w.iri(PROV.wasAssociatedWith, input.associatedAgentIri);
+  return graph;
+}
+
+export interface VersionHistoryEntry {
+  readonly version: string;
+  readonly generatedAt: string;
+  readonly changeSummary?: string;
+}
+
+export interface VersionEmitAllInput {
+  readonly registerId: string;
+  readonly datasetIri: string;
+  readonly versions: readonly VersionHistoryEntry[];
+  readonly associatedAgentIri?: string;
+}
+
+export function emitVersionHistory(input: VersionEmitAllInput): RdfGraph {
+  const graph = new RdfGraph();
+  let previousIri: string | undefined;
+  for (const v of input.versions) {
+    const versionIri = `${input.datasetIri}versions/${v.version}`;
+    const single = emitVersionGraph({
+      registerId: input.registerId,
+      version: v.version,
+      versionIri,
+      datasetIri: input.datasetIri,
+      generatedAt: v.generatedAt,
+      previousVersionIri: previousIri,
+      changeSummary: v.changeSummary,
+      associatedAgentIri: input.associatedAgentIri,
+    });
+    graph.merge(single);
+    previousIri = versionIri;
+  }
+  return graph;
+}

package/src/components/concept-rdf/vocabulary-emitter.ts

@@ -0,0 +1,62 @@
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { SKOS } from './predicates';
+import { RdfGraph } from './rdf-graph';
+import type { RdfGraph as RdfGraphType } from './rdf-graph';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const VOCAB_PATH = join(__dirname, '..', '..', '..', 'data', 'glossarist-vocab.json');
+
+export interface VocabTerm {
+  readonly iri: string;
+  readonly label: string;
+  readonly group?: string;
+}
+
+export interface VocabScheme {
+  readonly schemeIri: string;
+  readonly label: string;
+  readonly terms: readonly VocabTerm[];
+}
+
+interface VocabFile {
+  readonly schemes: readonly VocabScheme[];
+}
+
+let cached: VocabFile | undefined;
+
+export function loadVocabulary(path: string = VOCAB_PATH): VocabFile {
+  if (cached && path === VOCAB_PATH) return cached;
+  const text = readFileSync(path, 'utf8');
+  cached = JSON.parse(text) as VocabFile;
+  return cached;
+}
+
+export const VOCAB_SCHEMES: readonly VocabScheme[] = loadVocabulary().schemes;
+
+export function emitVocabularyGraph(graph: RdfGraphType = new RdfGraph()): RdfGraphType {
+  for (const scheme of VOCAB_SCHEMES) {
+    const schemeW = graph.declare(scheme.schemeIri, {
+      types: [SKOS.ConceptScheme],
+      label: scheme.label,
+      classLabel: 'ConceptScheme',
+      classId: SKOS.ConceptScheme,
+    });
+    for (const term of scheme.terms) {
+      const termW = graph.declare(term.iri, {
+        types: [SKOS.Concept],
+        label: term.label,
+        classLabel: 'Concept',
+        classId: SKOS.Concept,
+      });
+      termW.iri(SKOS.inScheme, scheme.schemeIri);
+      schemeW.iri(SKOS.hasTopConcept, term.iri);
+    }
+  }
+  return graph;
+}
+
+export function listVocabSchemes(): readonly VocabScheme[] {
+  return VOCAB_SCHEMES;
+}

package/src/components/figure/FigureDisplay.vue

@@ -10,7 +10,7 @@
  * so `{{fig:id}}` mentions can scroll to it via the cross-ref composable.
  */
 import { computed, ref } from 'vue';
-import type { Figure } from '../../adapters/non-verbal/types';
+import type { Figure } from 'glossarist';
 import { useNonVerbalEntity } from '../../composables/use-non-verbal-entity';
 import { resolveFallbackChain } from '../../utils/locale';
 import { anchorId } from '../../utils/non-verbal-anchor';
@@ -34,39 +34,40 @@ const id = () => props.entityId;
 const { entity, state, error } = useNonVerbalEntity(k, ds, id);
 
 const fallbackChain = computed(() => resolveFallbackChain(props.datasetLocales));
-const layout = computed(() => entity.value ? deriveLayout(entity.value as Figure) : 'single');
+const fig = computed(() => entity.value as Figure | null);
+const layout = computed(() => fig.value ? deriveLayout(fig.value) : 'single');
 const anchor = computed(() => anchorId('figure', props.datasetId, props.entityId));
 const descriptionId = computed(() => `${anchor.value}-desc`);
 
-const topLevelImages = computed(() => (entity.value as Figure | null)?.images ?? []);
+const topLevelImages = computed(() => fig.value?.images ?? []);
 </script>
 
 <template>
   <figure
-    v-if="entity && state === 'loaded'"
+    v-if="fig && state === 'loaded'"
     :id="anchor"
     :class="`figure figure--${layout}`"
   >
     <div v-if="topLevelImages.length" :class="`figure__media figure__media--${layout}`">
       <FigureImages
         :images="topLevelImages"
-        :alt="(entity as Figure).alt"
+        :alt="fig.alt"
         :dataset-id="datasetId"
         :locale="locale"
         :fallback-chain="fallbackChain"
-        :hasDescription="!!(entity as Figure).description && Object.keys((entity as Figure).description ?? {}).length > 0"
+        :hasDescription="!!fig.description && Object.keys(fig.description ?? {}).length > 0"
         :description-id="descriptionId"
         entity-label="Figure"
       />
     </div>
 
-    <template v-if="(entity as Figure).subfigures?.length">
+    <template v-if="fig.subfigures?.length">
       <div :class="`figure__subfigures figure__subfigures--${layout}`">
         <FigureDisplay
-          v-for="sub in (entity as Figure).subfigures"
-          :key="sub.id"
+          v-for="sub in fig.subfigures"
+          :key="sub.id ?? ''"
           :dataset-id="datasetId"
-          :entity-id="sub.id"
+          :entity-id="sub.id ?? ''"
           :locale="locale"
           :dataset-locales="datasetLocales"
         />
@@ -74,17 +75,17 @@ const topLevelImages = computed(() => (entity.value as Figure | null)?.images ??
     </template>
 
     <NonVerbalCaption
-      :identifier="(entity as Figure).identifier"
-      :caption="(entity as Figure).caption"
-      :description="(entity as Figure).description"
+      :identifier="fig.identifier"
+      :caption="fig.caption"
+      :description="fig.description"
       :locale="locale"
       :fallback-chain="fallbackChain"
       :description-id="descriptionId"
     />
 
     <NonVerbalSources
-      v-if="(entity as Figure).sources?.length"
-      :sources="(entity as Figure).sources!"
+      v-if="fig.sources?.length"
+      :sources="fig.sources"
     />
   </figure>
 

package/src/components/figure/FigureImages.vue

@@ -1,12 +1,15 @@
 <script setup lang="ts">
 import { computed } from 'vue';
-import type { FigureImage, LocalizedString } from '../../adapters/non-verbal/types';
+import type { FigureImage } from 'glossarist';
+import type { LocalizedString, NonVerbRepImage } from '../../adapters/non-verbal/types';
 import { pickLocaleText, hasLocale } from '../../utils/locale';
 import { getFactory } from '../../adapters/factory';
 
+type ImageLike = FigureImage | NonVerbRepImage;
+
 const props = withDefaults(defineProps<{
-  images: FigureImage[];
-  alt?: LocalizedString;
+  images: ImageLike[];
+  alt?: LocalizedString | null;
   datasetId: string;
   locale: string;
   fallbackChain?: readonly string[];
@@ -19,7 +22,19 @@ const props = withDefaults(defineProps<{
 
 const resolver = getFactory().nonVerbalResolver;
 
-const altText = computed(() => pickLocaleText(props.alt, props.locale, props.fallbackChain));
+function imgSrc(img: ImageLike): string {
+  return typeof img.src === 'string' ? img.src : '';
+}
+function imgFormat(img: ImageLike): string {
+  const f = img.format;
+  return typeof f === 'string' ? f : 'svg';
+}
+function imgRole(img: ImageLike): string | null {
+  const r = img.role;
+  return typeof r === 'string' ? r : null;
+}
+
+const altText = computed(() => pickLocaleText(props.alt ?? undefined, props.locale, props.fallbackChain));
 const altMissing = computed(() => !props.alt || Object.keys(props.alt).length === 0);
 const altEmpty = computed(() =>
   !!props.alt && hasLocale(props.alt, props.locale) && props.alt[props.locale] === '',
@@ -30,26 +45,33 @@ interface SourceVariant { src: string; type: string; media?: string; }
 const sourceVariants = computed<SourceVariant[]>(() => {
   const out: SourceVariant[] = [];
   for (const img of props.images) {
-    if (!img.role || img.role === 'vector' || img.role === 'raster') continue;
-    const src = resolver.resolveImageUrl(props.datasetId, img.src);
-    const type = img.format === 'svg' ? 'image/svg+xml' : `image/${img.format === 'jpg' ? 'jpeg' : img.format}`;
+    const role = imgRole(img);
+    if (!role || role === 'vector' || role === 'raster') continue;
+    const src = imgSrc(img);
+    const format = imgFormat(img);
+    if (!src) continue;
+    const type = format === 'svg' ? 'image/svg+xml' : `image/${format === 'jpg' ? 'jpeg' : format}`;
     let media: string | undefined;
-    if (img.role === 'dark') media = '(prefers-color-scheme: dark)';
-    else if (img.role === 'light') media = '(prefers-color-scheme: light)';
-    else if (img.role === 'print') media = 'print';
-    out.push({ src, type, media });
+    if (role === 'dark') media = '(prefers-color-scheme: dark)';
+    else if (role === 'light') media = '(prefers-color-scheme: light)';
+    else if (role === 'print') media = 'print';
+    out.push({ src: resolver.resolveImageUrl(props.datasetId, src), type, media });
   }
   return out;
 });
 
 const defaultImg = computed(() => {
-  const nonRole = props.images.find(i => !i.role || i.role === 'vector' || i.role === 'raster');
+  const nonRole = props.images.find(i => {
+    const r = imgRole(i);
+    return !r || r === 'vector' || r === 'raster';
+  });
   const chosen = nonRole ?? props.images[0];
-  if (!chosen) return null;
+  const src = chosen ? imgSrc(chosen) : '';
+  if (!src) return null;
   return {
-    src: resolver.resolveImageUrl(props.datasetId, chosen.src),
-    width: chosen.width,
-    height: chosen.height,
+    src: resolver.resolveImageUrl(props.datasetId, src),
+    width: chosen?.width ?? undefined,
+    height: chosen?.height ?? undefined,
   };
 });
 </script>

package/src/components/figure/figure-image-pick.ts

@@ -11,7 +11,7 @@
  * The `print` role is reserved for print stylesheets (selected via CSS
  * @media print in FigureImages.vue), not picked here.
  */
-import type { FigureImage } from '../../adapters/non-verbal/types';
+import type { FigureImage } from 'glossarist';
 
 export interface PickOptions {
   prefersDark?: boolean;

package/src/components/figure/figure-layout.ts

@@ -12,7 +12,7 @@
  * Authors who want different behavior can split a composite figure into
  * multiple top-level figures. V1 does not expose a `layout` field.
  */
-import type { Figure } from '../../adapters/non-verbal/types';
+import type { Figure } from 'glossarist';
 
 export type FigureLayout = 'single' | 'row' | 'column' | 'grid';