glossarist 0.4.5 → 0.4.6

package/data/concept-model/shapes/glossarist.shacl.ttl

@@ -8,11 +8,15 @@
 @prefix gloss:  <https://www.glossarist.org/ontologies/> .
 @prefix sh:     <http://www.w3.org/ns/shacl#> .
 @prefix skos:   <http://www.w3.org/2004/02/skos/core#> .
-@prefix xl:     <http://www.w3.org/2008/05/skos-xl#> .
+@prefix skosxl: <http://www.w3.org/2008/05/skos-xl#> .
 @prefix dcterms: <http://purl.org/dc/terms/> .
 @prefix xsd:    <http://www.w3.org/2001/XMLSchema#> .
 @prefix rdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
 @prefix rdfs:   <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix owl:    <http://www.w3.org/2002/07/owl#> .
+@prefix prov:   <http://www.w3.org/ns/prov#> .
+@prefix foaf:   <http://xmlns.com/foaf/0.1/> .
+@prefix dcat:   <http://www.w3.org/ns/dcat#> .
 
 # ══════════════════════════════════════════════════════════════════════════
 # Concept shapes
@@ -175,9 +179,9 @@ gloss:ConceptCollectionShape a sh:NodeShape ;
 
 gloss:DesignationShape a sh:NodeShape ;
   sh:targetClass gloss:Designation ;
-  sh:class xl:Label ;
+  sh:class skosxl:Label ;
   sh:property [
-    sh:path xl:literalForm ;
+    sh:path skosxl:literalForm ;
     sh:minCount 1 ;
     sh:maxCount 1 ;
   ] ;
@@ -430,6 +434,108 @@ gloss:NonVerbalRepresentationShape a sh:NodeShape ;
     sh:class gloss:ConceptSource ;
   ] .
 
+# === K1: Non-verbal entity shapes ===
+# Class declarations (NonVerbalEntity, Figure, Table, Formula, SharedNonVerbalEntity)
+# live in glossarist.ttl — this file contains validation shapes only.
+
+gloss:FigureShape a sh:NodeShape ;
+  sh:targetClass gloss:Figure ;
+  sh:property [
+    sh:path gloss:image ;
+    sh:datatype xsd:anyURI ;
+    sh:minCount 1 ;
+  ] ;
+  sh:property [
+    sh:path gloss:caption ;
+    sh:datatype xsd:string ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path dcterms:description ;
+    sh:datatype xsd:string ;
+    sh:maxCount 1 ;
+  ] .
+
+gloss:TableShape a sh:NodeShape ;
+  sh:targetClass gloss:Table ;
+  sh:property [
+    sh:path gloss:content ;
+    sh:datatype xsd:string ;
+    sh:minCount 1 ;
+  ] ;
+  sh:property [
+    sh:path gloss:caption ;
+    sh:datatype xsd:string ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path dcterms:title ;
+    sh:datatype xsd:string ;
+    sh:maxCount 1 ;
+  ] .
+
+gloss:FormulaShape a sh:NodeShape ;
+  sh:targetClass gloss:Formula ;
+  sh:property [
+    sh:path gloss:expression ;
+    sh:datatype xsd:string ;
+    sh:minCount 1 ;
+  ] ;
+  sh:property [
+    sh:path gloss:latexForm ;
+    sh:datatype xsd:string ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path dcterms:description ;
+    sh:datatype xsd:string ;
+    sh:maxCount 1 ;
+  ] .
+
+# === K2: Image binary references ===
+
+gloss:ImageShape a sh:NodeShape ;
+  sh:targetClass foaf:Image ;
+  sh:property [
+    sh:path dcterms:format ;
+    sh:datatype xsd:string ;
+    sh:minCount 1 ;
+  ] ;
+  sh:property [
+    sh:path dcterms:language ;
+    sh:datatype xsd:string ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path dcat:byteSize ;
+    sh:datatype xsd:integer ;
+    sh:maxCount 1 ;
+  ] .
+
+# === K4: NonVerbalRepresentation (concept-level NVR) ===
+# Class declaration lives in glossarist.ttl as gloss:NonVerbalRepresentation.
+
+gloss:NonVerbalRepresentationShape a sh:NodeShape ;
+  sh:targetClass gloss:NonVerbalRepresentation ;
+  sh:property [
+    sh:path skosxl:prefLabel ;
+    sh:minCount 1 ;
+  ] ;
+  sh:property [
+    sh:path gloss:image ;
+    sh:datatype xsd:anyURI ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path dcterms:description ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path prov:wasDerivedFrom ;
+    sh:class prov:Entity ;
+    sh:maxCount 1 ;
+  ] .
+
 gloss:ReferenceShape a sh:NodeShape ;
   sh:targetClass gloss:Reference ;
   sh:or (
@@ -696,6 +802,11 @@ gloss:SectionShape a sh:NodeShape ;
     sh:path gloss:hasChildSection ;
     sh:class gloss:Section ;
   ] ;
+  sh:property [
+    sh:path gloss:hasParentSection ;
+    sh:class gloss:Section ;
+    sh:maxCount 1 ;
+  ] ;
   sh:property [
     sh:path gloss:sectionOrdering ;
     sh:class skos:Concept ;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glossarist",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "JavaScript SDK for Glossarist GCR packages — read, write, validate, and manage terminology concepts",
   "type": "module",
   "main": "src/index.js",

package/src/models/figure.js

@@ -34,6 +34,10 @@ export class Figure extends SharedNonVerbalEntity {
     this._subfigures = null;
   }
 
+  rdfClass() {
+    return 'Figure';
+  }
+
   get images() {
     return this._lazy('_images', '_rawImages',
       i => i instanceof FigureImage ? i : new FigureImage(i));

package/src/models/formula.js

@@ -8,6 +8,10 @@ export class Formula extends SharedNonVerbalEntity {
     this.notation = data.notation ?? null;
   }
 
+  rdfClass() {
+    return 'Formula';
+  }
+
   toJSON() {
     const obj = super.toJSON();
     if (this.expression != null) obj.expression = this.expression;

package/src/models/non-verb-rep.js

@@ -11,6 +11,10 @@ export class NonVerbRep extends NonVerbalEntity {
     this._images = null;
   }
 
+  rdfClass() {
+    return 'NonVerbalRepresentation';
+  }
+
   get images() {
     return this._lazy('_images', '_rawImages',
       i => i instanceof FigureImage ? i : new FigureImage(i));

package/src/models/non-verbal-entity.js

@@ -16,6 +16,13 @@ export class NonVerbalEntity extends RegistrableModel {
       s => s instanceof ConceptSource ? s : new ConceptSource(s));
   }
 
+  // Ontology class local-name. Subtypes override to return their specific
+  // class (Figure/Table/Formula). Used by the RDF emitter so a new subtype
+  // registers without editing the emitter (OCP).
+  rdfClass() {
+    return 'NonVerbalEntity';
+  }
+
   findById(_targetId) {
     return null;
   }

package/src/models/table.js

@@ -8,6 +8,10 @@ export class Table extends SharedNonVerbalEntity {
     this.format = data.format ?? null;
   }
 
+  rdfClass() {
+    return 'Table';
+  }
+
   toJSON() {
     const obj = super.toJSON();
     if (this.content != null) obj.content = this.content;

package/src/rdf/gloss-concept.js

@@ -2,12 +2,31 @@
 //
 // URI shape: `<uriBase>/<registerId>/concept/<conceptId>`.
 // Localized concepts: `<uriBase>/<registerId>/concept/<conceptId>/<lang>`.
+// Figure/Table/Formula references: `<uriBase>/<registerId>/<kind>/<entityId>`.
 import { PRED } from './predicates.js';
 import { WELL_KNOWN } from './prefixes.js';
 import { localizedConceptToQuads } from './gloss-localized-concept.js';
 import { conceptSourceToQuads } from './gloss-source.js';
 import { namedNode, literal, quad } from './terms.js';
 
+// Kind tag → URI segment. Each NonVerbalReference subtype has a
+// predictable URL path so the same entity is reachable from any
+// concept that references it.
+const NVR_KIND_SEGMENT = {
+  FigureReference: 'figure',
+  TableReference: 'table',
+  FormulaReference: 'formula',
+};
+
+// Builds the URI for a NonVerbalReference target entity. Returns null
+// when the reference has no entityId (e.g., inline display-only refs).
+function nonVerbalReferenceUri(ref, options) {
+  const kind = NVR_KIND_SEGMENT[ref.constructor.name];
+  if (!kind || !ref.entityId) return null;
+  const base = String(options.uriBase ?? '').replace(/\/+$/, '');
+  return `${base}/${options.registerId}/${kind}/${ref.entityId}`;
+}
+
 export function conceptUri(concept, { registerId, uriBase }) {
   const id = String(concept.id ?? concept.termid ?? '');
   const base = String(uriBase ?? '').replace(/\/+$/, '');
@@ -27,6 +46,16 @@ export function* conceptToQuads(concept, options) {
     yield quad(s, namedNode(PRED.gloss.hasStatus), namedNode(`${PRED.gloss.$ns}status/${concept.status}`));
   }
 
+  // NonVerbal references — emit the link quad only. The actual
+  // Figure/Table/Formula entity quads are emitted by `nonVerbalEntityToQuads`
+  // when the dataset's NVR collection is iterated.
+  for (const ref of [...(concept.figures ?? []), ...(concept.tables ?? []), ...(concept.formulas ?? [])]) {
+    const targetUri = nonVerbalReferenceUri(ref, options);
+    if (targetUri) {
+      yield quad(s, namedNode(PRED.gloss.hasNonVerbalRep), namedNode(targetUri));
+    }
+  }
+
   for (const lang of concept.languages) {
     const lc = concept.localization(lang);
     if (!lc) continue;

package/src/rdf/gloss-localized-concept.js

@@ -10,6 +10,7 @@ import { WELL_KNOWN } from './prefixes.js';
 import { designationToQuads, skosLabelPredicate } from './gloss-designation.js';
 import { detailedDefinitionToQuads } from './gloss-detailed-definition.js';
 import { conceptSourceToQuads } from './gloss-source.js';
+import { nonVerbalRepToQuads } from './gloss-non-verbal-rep.js';
 import { namedNode, literal, quad } from './terms.js';
 const DCTERMS_LANGUAGE = `${PREFIXES.dcterms}language`;
 
@@ -55,6 +56,12 @@ export function* localizedConceptToQuads(localizedConcept, { parentUri, language
   yield* definitionsToQuads(localizedConcept.examples, { subjectUri, language, role: 'hasExample' });
   yield* definitionsToQuads(localizedConcept.annotations, { subjectUri, language, role: 'hasAnnotation' });
 
+  let nvrIndex = 0;
+  for (const nvr of localizedConcept.nonVerbalRep ?? []) {
+    yield* nonVerbalRepToQuads(nvr, { parentUri: subjectUri, index: nvrIndex, language });
+    nvrIndex += 1;
+  }
+
   let srcIndex = 0;
   for (const source of localizedConcept.sources ?? []) {
     yield* conceptSourceToQuads(source, { subjectUri, index: srcIndex });

package/src/rdf/gloss-non-verbal-rep.js

@@ -0,0 +1,191 @@
+// NonVerbal entity → RDF quads. Mirrors the v3.1.0 concept-model
+// NonVerbal class hierarchy. Two distinct shapes:
+//
+// 1. Legacy `gloss:NonVerbalRepresentation` (NonVerbRep) — a child of
+//    LocalizedConcept with a positional bnode subject. Carries
+//    `representationType`, `representationRef`, `representationText`.
+//
+// 2. Dataset-level `gloss:Figure` / `gloss:Table` / `gloss:Formula`
+//    (SharedNonVerbalEntity subtypes) — first-class resources with
+//    their own URIs. Carries caption, description, altText, sources,
+//    plus subtype-specific fields (Figure: images + subfigures;
+//    Table: content + format; Formula: expression + notation +
+//    latexForm).
+//
+// The dispatch on the entity's `rdfClass()` follows the same OCP
+// pattern as Designation — a new subtype registers without editing
+// this emitter.
+import { PRED, PREFIXES } from './predicates.js';
+import { WELL_KNOWN } from './prefixes.js';
+import { deterministicBnode } from './deterministic-id.js';
+import { namedNode, literal, quad } from './terms.js';
+import { conceptSourceToQuads } from './gloss-source.js';
+
+const DCTERMS_DESCRIPTION = `${PREFIXES.dcterms}description`;
+const DCTERMS_FORMAT = `${PREFIXES.dcterms}format`;
+const XSD_STRING = `${PREFIXES.xsd}string`;
+
+// ── Legacy NonVerbRep (concept-local, positional) ──────────────────────
+
+// Emits a `gloss:NonVerbalRepresentation` blank node linked from the
+// parent localized concept via `gloss:hasNonVerbalRep`. Mirrors the
+// Ruby `Rdf::GlossNonVerbalRep` shape: type/ref/text plus sources.
+export function* nonVerbalRepToQuads(nvr, { parentUri, index, language = null }) {
+  const subject = deterministicBnode(parentUri, 'nvr', index);
+
+  yield quad(namedNode(parentUri), namedNode(PRED.gloss.hasNonVerbalRep), namedNode(subject));
+  yield quad(namedNode(subject), namedNode(WELL_KNOWN.rdfType), namedNode(`${PRED.gloss.$ns}${nvr.rdfClass()}`));
+
+  if (nvr.type) {
+    yield quad(namedNode(subject), namedNode(PRED.gloss.representationType), literal(nvr.type, XSD_STRING));
+  }
+  for (const image of nvr.images ?? []) {
+    if (image.src) {
+      yield quad(namedNode(subject), namedNode(PRED.gloss.image), literal(image.src, XSD_STRING));
+    }
+  }
+  if (nvr.caption) {
+    yield quad(namedNode(subject), namedNode(PRED.gloss.caption), literal(nvr.caption, language));
+  }
+  if (nvr.description) {
+    yield quad(namedNode(subject), namedNode(DCTERMS_DESCRIPTION), literal(nvr.description, language));
+  }
+  if (nvr.alt) {
+    yield quad(namedNode(subject), namedNode(PRED.gloss.altText), literal(nvr.alt, language));
+  }
+
+  let srcIndex = 0;
+  for (const source of nvr.sources ?? []) {
+    yield* conceptSourceToQuads(source, { subjectUri: subject, index: srcIndex });
+    srcIndex += 1;
+  }
+}
+
+// ── Dataset-level Figure / Table / Formula ────────────────────────────
+
+// URI scheme: `<uriBase>/<registerId>/<kind>/<id>` where `kind` is the
+// entity's rdfClass() lowercased (figure/table/formula). Stable across
+// runs and consumers.
+export function nonVerbalEntityUri(entity, { registerId, uriBase }) {
+  const id = String(entity.id ?? entity.identifier ?? '');
+  const kind = String(entity.rdfClass() ?? 'NonVerbalEntity').toLowerCase();
+  const base = String(uriBase ?? '').replace(/\/+$/, '');
+  return `${base}/${registerId}/${kind}/${id}`;
+}
+
+// Emits a dataset-level NonVerbalEntity (Figure/Table/Formula) as a
+// first-class resource. Calls into subtype-specific emitters via the
+// entity's class identity — OCP: a new subtype adds a branch in
+// `subtypeQuadsFor` without changing the public entry point.
+export function* nonVerbalEntityToQuads(entity, options) {
+  const subjectUri = nonVerbalEntityUri(entity, options);
+  const s = namedNode(subjectUri);
+
+  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(`${PRED.gloss.$ns}${entity.rdfClass()}`));
+
+  if (entity.caption) {
+    yield quad(s, namedNode(PRED.gloss.caption), literal(entity.caption, null));
+  }
+  if (entity.description) {
+    yield quad(s, namedNode(DCTERMS_DESCRIPTION), literal(entity.description, null));
+  }
+  if (entity.alt) {
+    yield quad(s, namedNode(PRED.gloss.altText), literal(entity.alt, null));
+  }
+
+  yield* subtypeQuadsFor(entity, s, options);
+
+  let srcIndex = 0;
+  for (const source of entity.sources ?? []) {
+    yield* conceptSourceToQuads(source, { subjectUri, index: srcIndex });
+    srcIndex += 1;
+  }
+}
+
+// Dispatch table: maps the entity's rdfClass() local name to a
+// subtype-specific quad generator. Adding a new subtype = adding a
+// branch here + an rdfClass() override on the model class.
+function* subtypeQuadsFor(entity, s, options) {
+  switch (entity.rdfClass()) {
+    case 'Figure':  yield* figureQuads(entity, s, options); break;
+    case 'Table':   yield* tableQuads(entity, s); break;
+    case 'Formula': yield* formulaQuads(entity, s); break;
+    // NonVerbalEntity base or unknown — no subtype-specific quads.
+  }
+}
+
+function* figureQuads(figure, s, options) {
+  let imgIndex = 0;
+  for (const image of figure.images ?? []) {
+    const imgSubject = deterministicBnode(s.value, 'image', imgIndex);
+    yield quad(s, namedNode(PRED.gloss.image), namedNode(imgSubject));
+    yield quad(namedNode(imgSubject), namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.FigureImage));
+    if (image.src) {
+      yield quad(namedNode(imgSubject), namedNode(PRED.gloss.src), literal(image.src, XSD_STRING));
+    }
+    if (image.format) {
+      yield quad(namedNode(imgSubject), namedNode(DCTERMS_FORMAT), literal(image.format, XSD_STRING));
+    }
+    if (image.role) {
+      yield quad(namedNode(imgSubject), namedNode(PRED.gloss.role), literal(image.role, XSD_STRING));
+    }
+    imgIndex += 1;
+  }
+
+  let subIndex = 0;
+  for (const sub of figure.subfigures ?? []) {
+    const subSubject = deterministicBnode(s.value, 'subfig', subIndex);
+    yield quad(s, namedNode(PRED.gloss.hasSubfigure), namedNode(subSubject));
+    // Subfigures recurse as their own Figure bnodes — same shape,
+    // different subject. We inline the base + subtype quads so the
+    // subfigure's images also resolve.
+    yield* subfigureQuads(sub, subSubject, options);
+    subIndex += 1;
+  }
+}
+
+// Sub-figure emitter — mirrors `nonVerbalEntityToQuads` but with a
+// pre-assigned bnode subject (subfigures don't get their own URI).
+function* subfigureQuads(figure, subjectUri, _options) {
+  const s = namedNode(subjectUri);
+  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(`${PRED.gloss.$ns}${figure.rdfClass()}`));
+
+  if (figure.caption) {
+    yield quad(s, namedNode(PRED.gloss.caption), literal(figure.caption, null));
+  }
+  if (figure.description) {
+    yield quad(s, namedNode(DCTERMS_DESCRIPTION), literal(figure.description, null));
+  }
+  if (figure.alt) {
+    yield quad(s, namedNode(PRED.gloss.altText), literal(figure.alt, null));
+  }
+
+  let imgIndex = 0;
+  for (const image of figure.images ?? []) {
+    const imgSubject = deterministicBnode(s.value, 'image', imgIndex);
+    yield quad(s, namedNode(PRED.gloss.image), namedNode(imgSubject));
+    yield quad(namedNode(imgSubject), namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.FigureImage));
+    if (image.src) {
+      yield quad(namedNode(imgSubject), namedNode(PRED.gloss.src), literal(image.src, XSD_STRING));
+    }
+    imgIndex += 1;
+  }
+}
+
+function* tableQuads(table, s) {
+  if (table.content) {
+    yield quad(s, namedNode(PRED.gloss.content), literal(table.content, null));
+  }
+  if (table.format) {
+    yield quad(s, namedNode(PRED.gloss.format), literal(table.format, XSD_STRING));
+  }
+}
+
+function* formulaQuads(formula, s) {
+  if (formula.expression) {
+    yield quad(s, namedNode(PRED.gloss.expression), literal(formula.expression, null));
+  }
+  if (formula.notation) {
+    yield quad(s, namedNode(PRED.gloss.latexForm), literal(formula.notation, XSD_STRING));
+  }
+}

package/src/rdf/index.d.ts

@@ -10,6 +10,7 @@ import type { LocalizedConcept } from '../models/index';
 import type { Designation } from '../models/index';
 import type { DetailedDefinition } from '../models/index';
 import type { ConceptSource } from '../models/index';
+import type { NonVerbRep, Figure, Table, Formula } from '../models/index';
 
 export { PRED, PREFIXES } from './predicates';
 export type PredicateMap = typeof PRED;
@@ -76,6 +77,26 @@ export interface ConceptSourceEmitOptions {
 
 export declare function conceptSourceToQuads(source: ConceptSource, options: ConceptSourceEmitOptions): Generator<Quad, void, unknown>;
 
+// ── Non-verbal representation emitters ─────────────────────────────────
+
+export interface NonVerbalRepEmitOptions {
+  parentUri: string;
+  index: number;
+  language?: string | null;
+}
+
+export declare function nonVerbalRepToQuads(nvr: NonVerbRep, options: NonVerbalRepEmitOptions): Generator<Quad, void, unknown>;
+
+export interface NonVerbalEntityEmitOptions {
+  registerId: string;
+  uriBase?: string;
+}
+
+export type NonVerbalEntity = Figure | Table | Formula;
+
+export declare function nonVerbalEntityUri(entity: NonVerbalEntity, options: NonVerbalEntityEmitOptions): string;
+export declare function nonVerbalEntityToQuads(entity: NonVerbalEntity, options: NonVerbalEntityEmitOptions): Generator<Quad, void, unknown>;
+
 export declare function collectQuads(quadsIterable: Iterable<Quad>): Quad[];
 
 export interface WriteTurtleOptions {
@@ -102,6 +123,7 @@ export interface ValidationReport {
   }>;
 }
 
-export declare function loadShapes(): Promise<Dataset>;
-export declare function validateShacl(dataDataset: Dataset, options?: { shapes?: Dataset }): Promise<ValidationReport>;
+export declare function loadShapes(options?: { shapesPath?: string }): Promise<Dataset>;
+export declare function validateShacl(dataDataset: Dataset, options?: { shapes?: Dataset; shapesPath?: string }): Promise<ValidationReport>;
+export declare function clearShapesCache(): void;
 export declare function quadsToDataset(quads: Iterable<Quad>): Dataset;

package/src/rdf/index.js

@@ -17,6 +17,11 @@ export {
 } from './gloss-designation.js';
 export { detailedDefinitionToQuads } from './gloss-detailed-definition.js';
 export { conceptSourceToQuads } from './gloss-source.js';
+export {
+  nonVerbalRepToQuads,
+  nonVerbalEntityToQuads,
+  nonVerbalEntityUri,
+} from './gloss-non-verbal-rep.js';
 export {
   collectQuads,
   writeTurtle,
@@ -24,4 +29,4 @@ export {
   writeJsonld,
   sortQuads,
 } from './document-writer.js';
-export { validateShacl, loadShapes, quadsToDataset } from './shacl.js';
+export { validateShacl, loadShapes, clearShapesCache, quadsToDataset } from './shacl.js';

package/src/rdf/predicates.d.ts

@@ -26,6 +26,12 @@ export declare const PRED = {
     "DesignationRelationship": "https://www.glossarist.org/ontologies/DesignationRelationship",
     "ConceptDate": "https://www.glossarist.org/ontologies/ConceptDate",
     "NonVerbalRepresentation": "https://www.glossarist.org/ontologies/NonVerbalRepresentation",
+    "NonVerbalEntity": "https://www.glossarist.org/ontologies/NonVerbalEntity",
+    "SharedNonVerbalEntity": "https://www.glossarist.org/ontologies/SharedNonVerbalEntity",
+    "Figure": "https://www.glossarist.org/ontologies/Figure",
+    "Table": "https://www.glossarist.org/ontologies/Table",
+    "Formula": "https://www.glossarist.org/ontologies/Formula",
+    "FigureImage": "https://www.glossarist.org/ontologies/FigureImage",
     "CustomLocality": "https://www.glossarist.org/ontologies/CustomLocality",
     "Locality": "https://www.glossarist.org/ontologies/Locality",
     "DatasetRegister": "https://www.glossarist.org/ontologies/DatasetRegister",
@@ -69,6 +75,16 @@ export declare const PRED = {
     "isTruncation": "https://www.glossarist.org/ontologies/isTruncation",
     "text": "https://www.glossarist.org/ontologies/text",
     "image": "https://www.glossarist.org/ontologies/image",
+    "caption": "https://www.glossarist.org/ontologies/caption",
+    "altText": "https://www.glossarist.org/ontologies/altText",
+    "description": "https://www.glossarist.org/ontologies/description",
+    "expression": "https://www.glossarist.org/ontologies/expression",
+    "latexForm": "https://www.glossarist.org/ontologies/latexForm",
+    "content": "https://www.glossarist.org/ontologies/content",
+    "hasSubfigure": "https://www.glossarist.org/ontologies/hasSubfigure",
+    "src": "https://www.glossarist.org/ontologies/src",
+    "format": "https://www.glossarist.org/ontologies/format",
+    "role": "https://www.glossarist.org/ontologies/role",
     "pronunciationContent": "https://www.glossarist.org/ontologies/pronunciationContent",
     "pronunciationLanguage": "https://www.glossarist.org/ontologies/pronunciationLanguage",
     "pronunciationScript": "https://www.glossarist.org/ontologies/pronunciationScript",
@@ -268,6 +284,12 @@ export type Predicate =
   | "https://www.glossarist.org/ontologies/DesignationRelationship"
   | "https://www.glossarist.org/ontologies/ConceptDate"
   | "https://www.glossarist.org/ontologies/NonVerbalRepresentation"
+  | "https://www.glossarist.org/ontologies/NonVerbalEntity"
+  | "https://www.glossarist.org/ontologies/SharedNonVerbalEntity"
+  | "https://www.glossarist.org/ontologies/Figure"
+  | "https://www.glossarist.org/ontologies/Table"
+  | "https://www.glossarist.org/ontologies/Formula"
+  | "https://www.glossarist.org/ontologies/FigureImage"
   | "https://www.glossarist.org/ontologies/CustomLocality"
   | "https://www.glossarist.org/ontologies/Locality"
   | "https://www.glossarist.org/ontologies/DatasetRegister"
@@ -311,6 +333,16 @@ export type Predicate =
   | "https://www.glossarist.org/ontologies/isTruncation"
   | "https://www.glossarist.org/ontologies/text"
   | "https://www.glossarist.org/ontologies/image"
+  | "https://www.glossarist.org/ontologies/caption"
+  | "https://www.glossarist.org/ontologies/altText"
+  | "https://www.glossarist.org/ontologies/description"
+  | "https://www.glossarist.org/ontologies/expression"
+  | "https://www.glossarist.org/ontologies/latexForm"
+  | "https://www.glossarist.org/ontologies/content"
+  | "https://www.glossarist.org/ontologies/hasSubfigure"
+  | "https://www.glossarist.org/ontologies/src"
+  | "https://www.glossarist.org/ontologies/format"
+  | "https://www.glossarist.org/ontologies/role"
   | "https://www.glossarist.org/ontologies/pronunciationContent"
   | "https://www.glossarist.org/ontologies/pronunciationLanguage"
   | "https://www.glossarist.org/ontologies/pronunciationScript"

package/src/rdf/predicates.js

@@ -26,6 +26,12 @@ export const PRED = {
     "DesignationRelationship": "https://www.glossarist.org/ontologies/DesignationRelationship",
     "ConceptDate": "https://www.glossarist.org/ontologies/ConceptDate",
     "NonVerbalRepresentation": "https://www.glossarist.org/ontologies/NonVerbalRepresentation",
+    "NonVerbalEntity": "https://www.glossarist.org/ontologies/NonVerbalEntity",
+    "SharedNonVerbalEntity": "https://www.glossarist.org/ontologies/SharedNonVerbalEntity",
+    "Figure": "https://www.glossarist.org/ontologies/Figure",
+    "Table": "https://www.glossarist.org/ontologies/Table",
+    "Formula": "https://www.glossarist.org/ontologies/Formula",
+    "FigureImage": "https://www.glossarist.org/ontologies/FigureImage",
     "CustomLocality": "https://www.glossarist.org/ontologies/CustomLocality",
     "Locality": "https://www.glossarist.org/ontologies/Locality",
     "DatasetRegister": "https://www.glossarist.org/ontologies/DatasetRegister",
@@ -69,6 +75,16 @@ export const PRED = {
     "isTruncation": "https://www.glossarist.org/ontologies/isTruncation",
     "text": "https://www.glossarist.org/ontologies/text",
     "image": "https://www.glossarist.org/ontologies/image",
+    "caption": "https://www.glossarist.org/ontologies/caption",
+    "altText": "https://www.glossarist.org/ontologies/altText",
+    "description": "https://www.glossarist.org/ontologies/description",
+    "expression": "https://www.glossarist.org/ontologies/expression",
+    "latexForm": "https://www.glossarist.org/ontologies/latexForm",
+    "content": "https://www.glossarist.org/ontologies/content",
+    "hasSubfigure": "https://www.glossarist.org/ontologies/hasSubfigure",
+    "src": "https://www.glossarist.org/ontologies/src",
+    "format": "https://www.glossarist.org/ontologies/format",
+    "role": "https://www.glossarist.org/ontologies/role",
     "pronunciationContent": "https://www.glossarist.org/ontologies/pronunciationContent",
     "pronunciationLanguage": "https://www.glossarist.org/ontologies/pronunciationLanguage",
     "pronunciationScript": "https://www.glossarist.org/ontologies/pronunciationScript",

package/src/rdf/shacl.js

@@ -91,8 +91,9 @@ export function quadsToDataset(quads) {
   return ds;
 }
 
-// Test-only: clears the shapes cache. Exported so tests can verify
-// independent caching per path without reaching into module internals.
-export function __clearShapesCacheForTests() {
+// Clears the in-memory shapes cache. Exposed as part of the public API
+// so callers (including tests) can force a fresh load when the
+// underlying shapes file changes during a process's lifetime.
+export function clearShapesCache() {
   SHAPES_CACHE.clear();
 }