glossarist 0.4.12 → 0.4.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glossarist",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "description": "JavaScript SDK for Glossarist GCR packages — read, write, validate, and manage terminology concepts",
   "type": "module",
   "main": "src/index.js",
@@ -91,10 +91,10 @@
     "@rdfjs/data-model": "^2.0.0",
     "@rdfjs/dataset": "^2.0.0",
     "js-yaml": "^5.0.0",
-    "jsonld": "^8.3.3",
+    "jsonld": "^9.0.0",
     "jszip": "^3.10.1",
     "n3": "^1.17.0",
-    "rdf-validate-shacl": "^0.4.0"
+    "rdf-validate-shacl": "^0.6.5"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",

package/src/models/bibliography-data.js

@@ -5,7 +5,12 @@ import { BibliographyEntry } from './bibliography-entry.js';
 export class BibliographyData extends GlossaristModel {
   constructor(data = {}) {
     super();
-    const entriesData = data.bibliography ?? data.entries ?? [];
+    let entriesData;
+    if (Array.isArray(data)) {
+      entriesData = data;
+    } else {
+      entriesData = data?.bibliography ?? data?.entries ?? [];
+    }
     this._rawEntries = Array.isArray(entriesData) ? entriesData : [];
     this._entries = null;
   }

package/src/models/index.d.ts

@@ -58,6 +58,7 @@ export const REGISTER_STATUSES: readonly string[];
 export class Register extends GlossaristModel {
   readonly schemaVersion: string;
   readonly id: string | null;
+  readonly name: string | Record<string, string> | null;
   readonly ref: string | null;
   readonly refAliases: string[];
   readonly year: number | null;
@@ -79,6 +80,7 @@ export class Register extends GlossaristModel {
   readonly sections: Section[];
   sectionById(id: string): Section | null;
   sectionName(sectionId: string, lang: string): string | null;
+  displayName(lang: string): string | null;
   static fromJSON(data: Record<string, unknown>): Register;
 }
 

package/src/models/register.js

@@ -14,6 +14,7 @@ export class Register extends GlossaristModel {
     super();
     this.schemaVersion = data.schema_version ?? data.schemaVersion ?? '3';
     this.id = data.id ?? null;
+    this.name = data.name ?? null;
     this.ref = data.ref ?? null;
     this.refAliases = data.refAliases ?? data.ref_aliases ?? [];
     this.year = data.year ?? null;
@@ -42,7 +43,7 @@ export class Register extends GlossaristModel {
   _extractRaw(data) {
     const known = new Set([
       'schema_version', 'schemaVersion',
-      'id', 'ref', 'refAliases', 'ref_aliases',
+      'id', 'name', 'ref', 'refAliases', 'ref_aliases',
       'year', 'urn', 'urnAliases', 'urn_aliases',
       'status', 'supersedes', 'owner',
       'sourceRepo', 'source_repo', 'tags',
@@ -138,6 +139,24 @@ export class Register extends GlossaristModel {
     return section ? section.name(lang) : null;
   }
 
+  // Localized display name. Returns the best-matching name string for
+  // the requested language, falling back to English, then to the first
+  // available language, then to null. Accepts three input shapes:
+  //   - null/undefined  → null
+  //   - string          → returned as-is for every language
+  //   - { eng, fra, ... } → language-resolved
+  displayName(lang) {
+    if (this.name == null) return null;
+    if (typeof this.name === 'string') return this.name;
+    if (typeof this.name === 'object') {
+      return this.name[lang]
+        ?? this.name.eng
+        ?? Object.values(this.name)[0]
+        ?? null;
+    }
+    return null;
+  }
+
   // Returns the hex color for the requested UI mode, falling back to
   // the single hex when the spec is a string. Returns null when no
   // color is set or when the requested mode is missing.
@@ -148,6 +167,7 @@ export class Register extends GlossaristModel {
   toJSON() {
     const obj = { ...this._raw, schema_version: this.schemaVersion };
     if (this.id != null) obj.id = this.id;
+    if (this.name != null) obj.name = this.name;
     if (this.ref != null) obj.ref = this.ref;
     if (this.refAliases.length > 0) obj.refAliases = [...this.refAliases];
     if (this.year != null) obj.year = this.year;

package/src/rdf/agents-emitter.js

@@ -7,12 +7,13 @@
 // prov:Organization, and the person is linked via prov:actedOnBehalfOf.
 
 import { namedNode, literal, quad } from './terms.js';
+import { PREFIXES } from './predicates.js';
+import { RDF_TYPE } from './curie.js';
 
-const PROV_NS = 'http://www.w3.org/ns/prov#';
-const FOAF_NS = 'http://xmlns.com/foaf/0.1/';
-const DCTERMS_NS = 'http://purl.org/dc/terms/';
-const RDFS_NS = 'http://www.w3.org/2000/01/rdf-schema#';
-const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const PROV_NS    = PREFIXES.prov;
+const FOAF_NS    = PREFIXES.foaf ?? 'http://xmlns.com/foaf/0.1/';
+const DCTERMS_NS = PREFIXES.dcterms;
+const RDFS_NS    = PREFIXES.rdfs;
 
 const PROV = {
   Person: `${PROV_NS}Person`,

package/src/rdf/bibliography-emitter.js

@@ -10,11 +10,14 @@
 // - dcterms:isPartOf (parent dataset)
 
 import { namedNode, literal, quad } from './terms.js';
+import { PREFIXES } from './predicates.js';
+import { RDF_TYPE } from './curie.js';
 
-const DCTERMS_NS = 'http://purl.org/dc/terms/';
-const FOAF_NS = 'http://xmlns.com/foaf/0.1/';
-const GLOSS_NS = 'https://www.glossarist.org/ontologies/';
-const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+// Namespace IRIs from canonical PREFIXES. foaf is absent from the
+// JSON-LD context (therefore not in PREFIXES) — declare locally.
+const DCTERMS_NS = PREFIXES.dcterms;
+const FOAF_NS    = PREFIXES.foaf ?? 'http://xmlns.com/foaf/0.1/';
+const GLOSS_NS   = PREFIXES.gloss;
 
 const DCTERMS = {
   BibliographicResource: `${DCTERMS_NS}BibliographicResource`,

package/src/rdf/bnode-id.js

@@ -0,0 +1,35 @@
+// Deterministic blank node ID strategy.
+//
+// Single source of truth for bnode IDs across all emitters. Previously
+// each emitter had its own local FNV-1a hash, producing different IDs
+// for the same logical bnode. This module replaces those with one
+// strategy: MD5 (via node:crypto) when available, FNV-1a fallback for
+// browser bundles.
+//
+// Cross-process stability matches glossarist-ruby's deterministic-id
+// when node:crypto is available. Within a single process, FNV-1a is
+// also stable.
+
+import { createHash } from 'node:crypto';
+
+function fnv1a(seed) {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return (h >>> 0).toString(16).padStart(8, '0');
+}
+
+export function deterministicBnodeId(...parts) {
+  const seed = parts.filter(p => p != null && p !== '').join('|');
+  if (!seed) return `b${fnv1a('empty')}`;
+  // MD5 matches glossarist-ruby's deterministic-id for cross-process
+  // stability. Truncated to 12 hex chars — enough collision resistance
+  // for bnode IDs within a single document.
+  try {
+    return createHash('md5').update(seed).digest('hex').slice(0, 12);
+  } catch {
+    return `b${fnv1a(seed)}`;
+  }
+}

package/src/rdf/build-activity-emitter.js

@@ -9,13 +9,14 @@
 // - prov:wasAssociatedWith for the CI bot agent
 
 import { namedNode, literal, quad } from './terms.js';
+import { PREFIXES } from './predicates.js';
+import { RDF_TYPE } from './curie.js';
 
-const PROV_NS = 'http://www.w3.org/ns/prov#';
-const DCTERMS_NS = 'http://purl.org/dc/terms/';
-const FOAF_NS = 'http://xmlns.com/foaf/0.1/';
-const GLOSS_NS = 'https://www.glossarist.org/ontologies/';
-const XSD_NS = 'http://www.w3.org/2001/XMLSchema#';
-const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const PROV_NS    = PREFIXES.prov;
+const DCTERMS_NS = PREFIXES.dcterms;
+const FOAF_NS    = PREFIXES.foaf ?? 'http://xmlns.com/foaf/0.1/';
+const GLOSS_NS   = PREFIXES.gloss;
+const XSD_NS     = PREFIXES.xsd;
 
 const PROV = {
   Activity: `${PROV_NS}Activity`,

package/src/rdf/curie.js

@@ -0,0 +1,45 @@
+// CURIE helpers — resolve/compact IRIs against the canonical PREFIXES.
+//
+// Single source of truth for CURIE ↔ IRI conversion. Previously
+// `resolveIri` was private to vocabulary-emitter and reimplemented
+// (incorrectly) in other emitters. Callers now import from here.
+
+import { PREFIXES } from './prefixes.js';
+
+const ABSOLUTE_SCHEMES = new Set(['http', 'https', 'urn', 'file', 'mailto', 'ftp']);
+
+export function isAbsoluteIri(s) {
+  if (typeof s !== 'string' || s.length === 0) return false;
+  if (s.startsWith('urn:')) return true;
+  const colon = s.indexOf(':');
+  if (colon < 1) return false;
+  return ABSOLUTE_SCHEMES.has(s.slice(0, colon));
+}
+
+export function resolveIri(iri, prefixes = PREFIXES) {
+  if (isAbsoluteIri(iri)) return iri;
+  const colon = iri.indexOf(':');
+  if (colon < 1) return iri;
+  const prefix = iri.slice(0, colon);
+  const local = iri.slice(colon + 1);
+  const base = prefixes[prefix];
+  return base ? `${base}${local}` : iri;
+}
+
+export function compactIri(iri, prefixes = PREFIXES) {
+  let best = null;
+  let bestLen = 0;
+  for (const [prefix, base] of Object.entries(prefixes)) {
+    if (iri.startsWith(base) && base.length > bestLen) {
+      best = `${prefix}:${iri.slice(base.length)}`;
+      bestLen = base.length;
+    }
+  }
+  return best ?? iri;
+}
+
+// Convenience constants — used by every emitter. Centralized here so
+// the IRI string appears in exactly one place.
+export const RDF_TYPE = `${PREFIXES.rdf}type`;
+export const RDF_VALUE = `${PREFIXES.rdf}value`;
+export const RDFS_LABEL = `${PREFIXES.rdfs}label`;

package/src/rdf/dataset-emitter.js

@@ -11,17 +11,17 @@
 // for cascading section membership).
 
 import { namedNode, blankNode, literal, quad } from './terms.js';
+import { PREFIXES } from './predicates.js';
+import { RDF_TYPE } from './curie.js';
+import { deterministicBnodeId } from './bnode-id.js';
 
-// Prefix namespaces used by this emitter. Hard-coded (not via PREFIXES)
-// because dcat and prov are absent from the JSON-LD context that
-// PREFIXES is generated from — they appear in instance data only.
-// See concept-model/prefixes.ttl for the canonical bindings.
-const DCAT_NS = 'http://www.w3.org/ns/dcat#';
-const DCTERMS_NS = 'http://purl.org/dc/terms/';
-const SKOS_NS = 'http://www.w3.org/2004/02/skos/core#';
-const PROV_NS = 'http://www.w3.org/ns/prov#';
-const GLOSS_NS = 'https://www.glossarist.org/ontologies/';
-const XSD_NS = 'http://www.w3.org/2001/XMLSchema#';
+// Namespace IRIs from the canonical PREFIXES — single source of truth.
+const DCAT_NS    = PREFIXES.dcat ?? 'http://www.w3.org/ns/dcat#';
+const DCTERMS_NS = PREFIXES.dcterms;
+const SKOS_NS    = PREFIXES.skos;
+const PROV_NS    = PREFIXES.prov;
+const GLOSS_NS   = PREFIXES.gloss;
+const XSD_NS     = PREFIXES.xsd;
 
 /**
  * @typedef {Object} DatasetDistribution
@@ -87,7 +87,6 @@ const GLOSS = {
 };
 const XSD_DATE = `${XSD_NS}date`;
 const XSD_INTEGER = `${XSD_NS}integer`;
-const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
 
 /**
  * Emits dcat:Dataset + skos:ConceptScheme quads for one register's
@@ -141,7 +140,7 @@ function* distributionToQuads(ds, dist) {
   // outside their parent dataset. Using blankNode() (not namedNode with
   // a "_:..." string) so the n3 writer serializes them as _:bXXXX
   // rather than <_:bXXXX> which would be an invalid IRI.
-  const distSubject = blankNode(`b${deterministicId('dist', dist.id, dist.downloadUrl)}`);
+  const distSubject = blankNode(`b${deterministicBnodeId('dist', dist.id, dist.downloadUrl)}`);
   yield quad(ds, namedNode(DCAT.distribution), distSubject);
   yield quad(distSubject, namedNode(RDF_TYPE), namedNode(DCAT.Distribution));
   yield quad(distSubject, namedNode(DCTERMS.title), literal(dist.title));
@@ -167,15 +166,5 @@ function* sectionToQuads(section) {
   }
 }
 
-// Local deterministic-id helper (avoid pulling crypto-bearing module
-// into this browser-safe file). Mirrors deterministicId's seed|join
-// pattern using a small hash. Repeated calls within one process are
-// stable; cross-process stability isn't required for blank node IDs.
-function deterministicId(...parts) {
-  const seed = parts.filter(p => p != null).join('|');
-  let h = 0;
-  for (let i = 0; i < seed.length; i++) {
-    h = ((h << 5) - h + seed.charCodeAt(i)) | 0;
-  }
-  return (h >>> 0).toString(16).padStart(8, '0');
-}
+// Local deterministic-id helper is no longer needed — using the shared
+// deterministicBnodeId from bnode-id.js for cross-emitter consistency.

package/src/rdf/group-emitter.js

@@ -12,13 +12,14 @@
 // Both kinds are also typed as skos:ConceptScheme for SKOS interop.
 
 import { namedNode, literal, quad } from './terms.js';
+import { PREFIXES } from './predicates.js';
+import { RDF_TYPE } from './curie.js';
 
-// Hard-coded namespaces — see dataset-emitter.js for rationale.
-const DCAT_NS = 'http://www.w3.org/ns/dcat#';
-const DCTERMS_NS = 'http://purl.org/dc/terms/';
-const SKOS_NS = 'http://www.w3.org/2004/02/skos/core#';
-const PROV_NS = 'http://www.w3.org/ns/prov#';
-const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+// Namespace IRIs from canonical PREFIXES.
+const DCAT_NS    = PREFIXES.dcat ?? 'http://www.w3.org/ns/dcat#';
+const DCTERMS_NS = PREFIXES.dcterms;
+const SKOS_NS    = PREFIXES.skos;
+const PROV_NS    = PREFIXES.prov;
 
 const DCAT = {
   DatasetSeries: `${DCAT_NS}DatasetSeries`,

package/src/rdf/image-variant-emitter.js

@@ -8,12 +8,13 @@
 // - dcat:downloadURL (canonical download)
 
 import { namedNode, literal, quad } from './terms.js';
+import { PREFIXES } from './predicates.js';
+import { RDF_TYPE } from './curie.js';
 
-const FOAF_NS = 'http://xmlns.com/foaf/0.1/';
-const DCTERMS_NS = 'http://purl.org/dc/terms/';
-const DCAT_NS = 'http://www.w3.org/ns/dcat#';
-const XSD_NS = 'http://www.w3.org/2001/XMLSchema#';
-const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const FOAF_NS    = PREFIXES.foaf ?? 'http://xmlns.com/foaf/0.1/';
+const DCTERMS_NS = PREFIXES.dcterms;
+const DCAT_NS    = PREFIXES.dcat ?? 'http://www.w3.org/ns/dcat#';
+const XSD_NS     = PREFIXES.xsd;
 
 const FOAF = {
   Image: `${FOAF_NS}Image`,

package/src/rdf/index.d.ts

@@ -107,7 +107,46 @@ export interface VocabScheme {
   label: string;
   terms: readonly VocabTerm[];
 }
-export declare function resolveIri(iri: string): string;
+
+// ── CURIE + bnode helpers ─────────────────────────────────────────────
+export declare const RDF_TYPE: string;
+export declare const RDF_VALUE: string;
+export declare const RDFS_LABEL: string;
+export declare function isAbsoluteIri(s: string): boolean;
+export declare function resolveIri(iri: string, prefixes?: Record<string, string>): string;
+export declare function compactIri(iri: string, prefixes?: Record<string, string>): string;
+export declare function deterministicBnodeId(...parts: Array<string | number | null | undefined>): string;
+
+// ── Sections builder (Quad[] → ClassInstance[] for UI) ────────────────
+export interface PropValue {
+  predicate: string;
+  values: string[];
+  nested?: boolean;
+}
+export interface ClassInstance {
+  classId: string;
+  classLabel: string;
+  label: string;
+  props: PropValue[];
+}
+export interface SectionsBuilderOptions {
+  language?: string;
+}
+export declare function quadSectionsToClassInstances(
+  quads: readonly Quad[],
+  options?: SectionsBuilderOptions,
+): ClassInstance[];
+
+// ── Provenance emitter (subject → prov:wasGeneratedBy + Activity) ─────
+export interface ProvenanceInput {
+  subjectUri: string;
+  serializer: string;
+  serializerVersion: string;
+  generatedAt: string;
+  canonicalUri?: string;
+}
+export declare function provenanceToQuads(input: ProvenanceInput): Generator<Quad, void, unknown>;
+
 export declare function vocabularySchemeToQuads(scheme: VocabScheme): Generator<Quad, void, unknown>;
 export declare function vocabularyToQuads(schemes: readonly VocabScheme[]): Generator<Quad, void, unknown>;
 

package/src/rdf/index.js

@@ -1,5 +1,14 @@
 // Public RDF layer. Mirrors lib/glossarist/rdf/ in glossarist-ruby.
 export { PRED, PREFIXES, SKOSXL, WELL_KNOWN } from './prefixes.js';
+export {
+  resolveIri,
+  compactIri,
+  isAbsoluteIri,
+  RDF_TYPE,
+  RDF_VALUE,
+  RDFS_LABEL,
+} from './curie.js';
+export { deterministicBnodeId } from './bnode-id.js';
 export { deterministicId, deterministicBnode } from './deterministic-id.js';
 export { namedNode, blankNode, literal, defaultGraph, quad } from './terms.js';
 export {
@@ -25,7 +34,6 @@ export {
 export {
   vocabularySchemeToQuads,
   vocabularyToQuads,
-  resolveIri,
 } from './vocabulary-emitter.js';
 export { datasetToQuads } from './dataset-emitter.js';
 export { groupToQuads } from './group-emitter.js';
@@ -43,3 +51,5 @@ export {
 } from './document-writer.js';
 export { writeTurtleSync } from './write-turtle-sync.js';
 export { validateShacl, loadShapes, clearShapesCache, quadsToDataset } from './shacl.js';
+export { quadSectionsToClassInstances } from './sections-builder.js';
+export { provenanceToQuads } from './provenance-emitter.js';

package/src/rdf/provenance-emitter.js

@@ -0,0 +1,87 @@
+// Provenance emitter — emits prov:wasGeneratedBy + prov:Activity quads
+// for any resource that needs build/view-time provenance.
+//
+// Replaces concept-browser's src/components/concept-rdf/provenance.ts
+// (runtime provenance at view-time). Same output shape, but operates
+// on standard RDF/JS Quad[] (no RdfGraph abstraction).
+
+import { namedNode, blankNode, literal, quad } from './terms.js';
+import { PREFIXES } from './predicates.js';
+import { RDF_TYPE, RDFS_LABEL } from './curie.js';
+import { deterministicBnodeId } from './bnode-id.js';
+
+const PROV_NS    = PREFIXES.prov;
+const DCTERMS_NS = PREFIXES.dcterms;
+const XSD_NS     = PREFIXES.xsd;
+
+const PROV = {
+  Activity:        `${PROV_NS}Activity`,
+  Entity:          `${PROV_NS}Entity`,
+  SoftwareAgent:   `${PROV_NS}SoftwareAgent`,
+  Agent:           `${PROV_NS}Agent`,
+  wasGeneratedBy:  `${PROV_NS}wasGeneratedBy`,
+  wasAssociatedWith: `${PROV_NS}wasAssociatedWith`,
+  generatedAtTime: `${PROV_NS}generatedAtTime`,
+  startedAtTime:   `${PROV_NS}startedAtTime`,
+  endedAtTime:     `${PROV_NS}endedAtTime`,
+};
+const DCTERMS = {
+  isVersionOf:  `${DCTERMS_NS}isVersionOf`,
+  title:        `${DCTERMS_NS}title`,
+};
+const FOAF_NS = PREFIXES.foaf ?? 'http://xmlns.com/foaf/0.1/';
+const XSD_DATETIME = `${XSD_NS}dateTime`;
+
+/**
+ * @typedef {Object} ProvenanceInput
+ * @property {string} subjectUri — the resource being provenance-tagged
+ * @property {string} serializer — e.g. "concept-browser"
+ * @property {string} serializerVersion — e.g. "0.7.66"
+ * @property {string} generatedAt — ISO 8601 date-time
+ * @property {string} [canonicalUri] — for dcterms:isVersionOf (versions)
+ */
+
+/**
+ * Emits provenance quads linking subjectUri to a prov:Activity
+ * performed by a prov:SoftwareAgent. The activity IRI is relative
+ * (under the document base): `activity/serializers/{serializer}/{version}`.
+ *
+ * Idempotent: same input always produces the same bnode IDs and the
+ * same set of quads.
+ *
+ * @param {ProvenanceInput} input
+ * @returns {Generator<import('@rdfjs/dataset').Quad, void, unknown>}
+ */
+export function* provenanceToQuads(input) {
+  if (!input?.subjectUri) throw new Error('provenanceToQuads: subjectUri is required');
+  if (!input?.serializer) throw new Error('provenanceToQuads: serializer is required');
+  if (!input?.serializerVersion) throw new Error('provenanceToQuads: serializerVersion is required');
+  if (!input?.generatedAt) throw new Error('provenanceToQuads: generatedAt is required');
+
+  const subject = namedNode(input.subjectUri);
+  const activityIri = namedNode(`activity/serializers/${input.serializer}/${input.serializerVersion}`);
+
+  // Subject is a prov:Entity, generated by the activity, at the timestamp
+  yield quad(subject, namedNode(RDF_TYPE), namedNode(PROV.Entity));
+  yield quad(subject, namedNode(PROV.wasGeneratedBy), activityIri);
+  yield quad(subject, namedNode(PROV.generatedAtTime), literal(input.generatedAt, namedNode(XSD_DATETIME)));
+
+  if (input.canonicalUri && input.canonicalUri !== input.subjectUri) {
+    yield quad(subject, namedNode(DCTERMS.isVersionOf), namedNode(input.canonicalUri));
+  }
+
+  // Activity is a prov:Activity, associated with the software agent
+  yield quad(activityIri, namedNode(RDF_TYPE), namedNode(PROV.Activity));
+  yield quad(activityIri, namedNode(RDFS_LABEL), literal(`${input.serializer} ${input.serializerVersion}`));
+
+  // Software agent as a deterministic blank node — same input always
+  // produces the same bnode ID so multiple subjects that share a
+  // serializer/version collapse to one agent.
+  const agentId = deterministicBnodeId('agent', input.serializer, input.serializerVersion);
+  const agent = blankNode(`b${agentId}`);
+  yield quad(activityIri, namedNode(PROV.wasAssociatedWith), agent);
+  yield quad(agent, namedNode(RDF_TYPE), namedNode(PROV.SoftwareAgent));
+  yield quad(agent, namedNode(RDF_TYPE), namedNode(PROV.Agent));
+  yield quad(agent, namedNode(RDFS_LABEL), literal(input.serializer));
+  yield quad(agent, namedNode(`${FOAF_NS}name`), literal(input.serializer));
+}

package/src/rdf/sections-builder.js

@@ -0,0 +1,170 @@
+// Sections builder — transforms a Quad[] into the ClassInstance[]
+// shape consumed by Vue UI components (RdfInstanceSection,
+// RdfInstanceHeader, RdfSourcePanel).
+//
+// The grouping logic is RDF-structure-driven, not Vue-specific:
+// 1. Group quads by subject (NamedNode or BlankNode)
+// 2. For each subject:
+//    - rdf:type values → classId (first type wins, multi-type joined)
+//    - Derive classLabel from classId local name (CURIE local part)
+//    - Derive label from skos:prefLabel/rdfs:label/URI segment
+//    - Collect remaining predicates → props
+// 3. For bnode objects, recursively nest their triples as a
+//    nested PropValue
+// 4. Return ClassInstance[] sorted by subject IRI (insertion order
+//    preserved when subjects appear in canonical order)
+//
+// This module consumes standard RDF/JS Quad[] — no custom RdfGraph
+// abstraction. Any consumer (Vue UI, CLI inspector, debug tool) can
+// use it.
+
+import { RDF_TYPE, RDFS_LABEL, compactIri } from './curie.js';
+import { PREFIXES } from './predicates.js';
+
+const SKOS_PREF_LABEL = `${PREFIXES.skos}prefLabel`;
+
+/**
+ * @typedef {Object} PropValue
+ * @property {string} predicate
+ * @property {string[]} values
+ * @property {boolean} [nested]
+ */
+/**
+ * @typedef {Object} ClassInstance
+ * @property {string} classId
+ * @property {string} classLabel
+ * @property {string} label
+ * @property {PropValue[]} props
+ */
+/**
+ * @typedef {Object} SectionsBuilderOptions
+ * @property {string} [language='eng'] — preferred language for skos:prefLabel
+ */
+
+/**
+ * Build ClassInstance[] from a Quad[]. Bnodes referenced as objects
+ * are recursively nested into the parent prop.
+ *
+ * @param {import('@rdfjs/dataset').Quad[]} quads
+ * @param {SectionsBuilderOptions} [options]
+ * @returns {ClassInstance[]}
+ */
+export function quadSectionsToClassInstances(quads, options = {}) {
+  const language = options.language ?? 'eng';
+  if (!quads || quads.length === 0) return [];
+
+  // Group quads by subject
+  const bySubject = new Map();
+  const bnodeQuads = new Map(); // separate bnode quads for nested lookup
+  const order = [];
+
+  for (const q of quads) {
+    const subj = q.subject;
+    const isBnode = subj.termType === 'BlankNode';
+    const key = subj.value;
+    const target = isBnode ? bnodeQuads : bySubject;
+    if (!target.has(key)) {
+      target.set(key, { subject: subj, quads: [] });
+      if (!isBnode) order.push(key);
+    }
+    target.get(key).quads.push(q);
+  }
+
+  const result = [];
+  for (const key of order) {
+    const entry = bySubject.get(key);
+    result.push(resourceToClassInstance(entry.subject, entry.quads, bnodeQuads, language));
+  }
+  return result;
+}
+
+function resourceToClassInstance(subject, quads, bnodeQuads, language) {
+  const types = [];
+  const otherQuads = [];
+  let prefLabel = null;
+  let rdfsLabel = null;
+
+  for (const q of quads) {
+    if (q.predicate.value === RDF_TYPE) {
+      types.push(q.object.value);
+    } else if (q.predicate.value === SKOS_PREF_LABEL) {
+      // Prefer prefLabel in the requested language; first one wins per lang
+      if (!prefLabel || (q.object.language === language && prefLabel.language !== language)) {
+        prefLabel = { value: q.object.value, language: q.object.language };
+      }
+    } else if (q.predicate.value === RDFS_LABEL && !rdfsLabel) {
+      rdfsLabel = q.object.value;
+    } else {
+      otherQuads.push(q);
+    }
+  }
+
+  const subjectStr = subject.value;
+  const classId = types.length > 0 ? types[0] : '';
+  const classLabel = deriveClassLabel(classId);
+  const label = prefLabel?.value ?? rdfsLabel ?? deriveSubjectLabel(subjectStr);
+
+  // Group predicates (preserve insertion order)
+  const props = [];
+  const seenPredKeys = new Set();
+
+  for (const q of otherQuads) {
+    const isBnodeObj = q.object.termType === 'BlankNode';
+    const formatted = formatTerm(q.object, bnodeQuads);
+    if (formatted === '') continue;
+    const dedupKey = `${q.predicate.value}#${isBnodeObj ? 'n' : 'f'}#${formatted}`;
+    if (seenPredKeys.has(dedupKey)) continue;
+    seenPredKeys.add(dedupKey);
+
+    const prop = { predicate: q.predicate.value, values: [formatted] };
+    if (isBnodeObj) prop.nested = true;
+    props.push(prop);
+  }
+
+  return {
+    classId,
+    classLabel,
+    label,
+    props,
+  };
+}
+
+function formatTerm(term, bnodeQuads) {
+  switch (term.termType) {
+    case 'NamedNode':
+      return term.value;
+    case 'Literal':
+      return term.value;
+    case 'BlankNode': {
+      const entry = bnodeQuads.get(term.value);
+      if (!entry) return '';
+      const parts = entry.quads.map(q => {
+        const val = formatTerm(q.object, bnodeQuads);
+        return val ? `${compactIri(q.predicate.value)}: ${val}` : '';
+      }).filter(p => p);
+      return parts.join('; ');
+    }
+    default:
+      return '';
+  }
+}
+
+function deriveClassLabel(classId) {
+  if (!classId) return '';
+  // CURIE case: "gloss:Concept" → "Concept"
+  if (!classId.includes('://') && classId.includes(':')) {
+    return classId.slice(classId.indexOf(':') + 1);
+  }
+  // Absolute IRI: take last path segment, strip fragment/query
+  const noFrag = classId.split('#').pop();
+  const last = noFrag.split('/').pop();
+  return last || classId;
+}
+
+function deriveSubjectLabel(subject) {
+  if (!subject) return '';
+  // Last path segment or fragment
+  const noFrag = subject.split('#').pop();
+  const last = noFrag.split('/').pop();
+  return last || subject;
+}

package/src/rdf/shacl.js

@@ -76,9 +76,14 @@ export async function loadShapes({ shapesPath = SHAPES_PATH } = {}) {
 // Options:
 //   - shapes: a pre-loaded Dataset to use instead of the default shapes
 //   - shapesPath: alternative path to load shapes from (cached per path)
+//
+// Note: rdf-validate-shacl 0.6+ requires a factory with clownface. The
+// library's default env (from defaultEnv.js) provides one — we no longer
+// pass a custom factory. Callers still control Dataset creation via
+// quadsToDataset below.
 export async function validateShacl(dataDataset, { shapes, shapesPath } = {}) {
   const shapesDataset = shapes ?? await loadShapes({ shapesPath });
-  const validator = new ShaclValidatorCtor(shapesDataset, { factory: FACTORY });
+  const validator = new ShaclValidatorCtor(shapesDataset);
   return validator.validate(dataDataset);
 }
 

package/src/rdf/version-emitter.js

@@ -9,11 +9,12 @@
 // - prov:wasAssociatedWith (optional agent)
 
 import { namedNode, literal, quad } from './terms.js';
+import { PREFIXES } from './predicates.js';
+import { RDF_TYPE } from './curie.js';
 
-const PROV_NS = 'http://www.w3.org/ns/prov#';
-const DCTERMS_NS = 'http://purl.org/dc/terms/';
-const XSD_NS = 'http://www.w3.org/2001/XMLSchema#';
-const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const PROV_NS    = PREFIXES.prov;
+const DCTERMS_NS = PREFIXES.dcterms;
+const XSD_NS     = PREFIXES.xsd;
 
 const PROV = {
   Entity: `${PROV_NS}Entity`,

package/src/rdf/vocabulary-emitter.js

@@ -14,9 +14,8 @@
 
 import { namedNode, literal, quad } from './terms.js';
 import { PREFIXES } from './predicates.js';
+import { resolveIri, RDF_TYPE, RDFS_LABEL } from './curie.js';
 
-const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
-const RDF_LABEL = 'http://www.w3.org/2000/01/rdf-schema#label';
 const SKOS_NS = PREFIXES.skos;
 
 /**
@@ -31,22 +30,6 @@ const SKOS_NS = PREFIXES.skos;
  * @property {readonly VocabTerm[]} terms
  */
 
-/**
- * Resolves a CURIE (e.g. "gloss:status/valid") to an absolute IRI
- * using PREFIXES. Pass-through if already absolute.
- */
-function resolveIri(iri) {
-  if (iri.startsWith('http://') || iri.startsWith('https://') || iri.startsWith('urn:')) {
-    return iri;
-  }
-  const colonIdx = iri.indexOf(':');
-  if (colonIdx < 0) return iri;
-  const prefix = iri.slice(0, colonIdx);
-  const local = iri.slice(colonIdx + 1);
-  const base = PREFIXES[prefix];
-  return base ? `${base}${local}` : iri;
-}
-
 /**
  * Emits SKOS ConceptScheme + Concept quads for one scheme.
  *
@@ -58,14 +41,14 @@ export function* vocabularySchemeToQuads(scheme) {
   const schemeSubject = namedNode(schemeIri);
 
   yield quad(schemeSubject, namedNode(RDF_TYPE), namedNode(`${SKOS_NS}ConceptScheme`));
-  yield quad(schemeSubject, namedNode(RDF_LABEL), literal(scheme.label, 'en'));
+  yield quad(schemeSubject, namedNode(RDFS_LABEL), literal(scheme.label, 'en'));
 
   for (const term of scheme.terms ?? []) {
     const termIri = resolveIri(term.iri);
     const termSubject = namedNode(termIri);
 
     yield quad(termSubject, namedNode(RDF_TYPE), namedNode(`${SKOS_NS}Concept`));
-    yield quad(termSubject, namedNode(RDF_LABEL), literal(term.label, 'en'));
+    yield quad(termSubject, namedNode(RDFS_LABEL), literal(term.label, 'en'));
     yield quad(termSubject, namedNode(`${SKOS_NS}inScheme`), schemeSubject);
     yield quad(schemeSubject, namedNode(`${SKOS_NS}hasTopConcept`), termSubject);
   }
@@ -82,6 +65,3 @@ export function* vocabularyToQuads(schemes) {
     yield* vocabularySchemeToQuads(scheme);
   }
 }
-
-// Re-exported for callers that want to resolve CURIEs themselves.
-export { resolveIri };