glossarist 0.4.7 → 0.4.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glossarist",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "JavaScript SDK for Glossarist GCR packages — read, write, validate, and manage terminology concepts",
   "type": "module",
   "main": "src/index.js",
@@ -42,6 +42,11 @@
       "import": "./src/rdf/index.js",
       "default": "./src/rdf/index.js"
     },
+    "./rdf/prefixes": {
+      "types": "./src/rdf/predicates.d.ts",
+      "import": "./src/rdf/predicates.js",
+      "default": "./src/rdf/predicates.js"
+    },
     "./transforms": {
       "types": "./src/transforms/index.d.ts",
       "import": "./src/transforms/index.js",

package/src/models/register.js

@@ -91,6 +91,31 @@ export class Register extends GlossaristModel {
     return [sectionId, ...this.sectionAncestorIds(sectionId)];
   }
 
+  // Walks the section tree DOWNWARD from `sectionId`, returning all
+  // descendant section IDs in pre-order (immediate children first,
+  // then their children). The returned array does NOT include
+  // sectionId itself. Returns [] when sectionId is unknown or is a
+  // leaf section. Useful for filtering concepts by parent section
+  // (include descendants) — the inverse direction of sectionClosure.
+  sectionDescendantIds(sectionId) {
+    if (!sectionId) return [];
+    const section = this.sectionById(sectionId);
+    if (!section) return [];
+    const out = [];
+    for (const child of section.children ?? []) {
+      out.push(child.id);
+      out.push(...this.sectionDescendantIds(child.id));
+    }
+    return out;
+  }
+
+  // Returns the descendant closure of `sectionId`: the section plus
+  // all of its descendants. Useful for "show me everything in section
+  // X or below" queries.
+  sectionDescendantClosure(sectionId) {
+    return [sectionId, ...this.sectionDescendantIds(sectionId)];
+  }
+
   // Returns all section IDs the concept belongs to: the concept's own
   // sections plus every ancestor of each. Concept-side section
   // membership comes from `concept.sections` if set, otherwise from

package/src/models/relation-categories.js

@@ -1,9 +1,24 @@
 // Categorization SSOT for the 52 glossarist relationship types.
 //
 // Each type in RELATIONSHIP_TYPES belongs to exactly one category. The
-// categories are semantic buckets used for filtering and visualization
-// in concept-browser. Bringing the categorization into glossarist-js
-// means all consumers see the same buckets.
+// categories mirror the concept-model taxonomy
+// (concept-browser:src/data/taxonomies.json) so JS consumers and the
+// Vue UI see the same buckets. Adding a new type means adding a
+// taxonomy entry — no code changes here.
+//
+// The 8 categories:
+//   lifecycle      — supersession, deprecation, replacement
+//   hierarchical   — SKOS + ISO 25964 broader/narrower (generic/partitive/instantial)
+//   associative    — generic see-also references
+//   comparative    — compare / contrast
+//   spatiotemporal — sequential, spatial, temporal
+//   lexical        — homograph, false_friend (cross-language)
+//   mapping        — SKOS mapping properties (cross-vocabulary)
+//   definitional   — ISO 19135 concept-to-concept relations: definition, part,
+//                    instance, inheritance, versioning
+//
+// Designation-level relationships (abbreviated_form_for, short_form_for)
+// are a separate concern — see DESIGNATION_RELATIONSHIP_TYPES.
 
 import { RELATIONSHIP_TYPES } from './related-concept.js';
 
@@ -75,22 +90,21 @@ export const RELATION_CATEGORIES = Object.freeze({
     ]),
   }),
 
-  conceptInstance: Object.freeze({
-    label: 'Concept / Instance',
-    description: 'ISO 19135 concept-to-concept relations: definition, part, instance, inheritance.',
+  // ISO 19135 concept-to-concept relations. Replaces the previous
+  // `conceptInstance` and `versioning` split — concept-browser's
+  // taxonomy treats versioning as part of the definitional cluster
+  // (a version IS a definitional variant of the same concept identity).
+  // Renaming aligns glossarist-js with the canonical taxonomy at
+  // concept-browser:src/data/taxonomies.json.
+  definitional: Object.freeze({
+    label: 'Definitional',
+    description: 'ISO 19135 concept-to-concept relations: definition, part, instance, inheritance, versioning.',
     types: Object.freeze([
       'has_concept', 'is_concept_of',
       'instance_of', 'has_instance',
       'has_definition', 'definition_of',
       'has_part', 'is_part_of',
       'inherits', 'inherited_by',
-    ]),
-  }),
-
-  versioning: Object.freeze({
-    label: 'Versioning',
-    description: 'Version lineage within the same concept identity.',
-    types: Object.freeze([
       'has_version', 'version_of',
       'current_version', 'current_version_of',
     ]),
@@ -106,6 +120,14 @@ const _CATEGORY_BY_TYPE = (() => {
   return map;
 })();
 
+// Backward-compat aliases for callers that adopted the original
+// glossarist-js naming (v0.4.6). Resolved at lookup time so any of
+// the three names returns the definitional category.
+const _CATEGORY_ALIASES = {
+  conceptInstance: 'definitional',
+  versioning: 'definitional',
+};
+
 /**
  * Returns the category key for the given relationship type, or null
  * when the type is not categorized (e.g. an unrecognized custom type).
@@ -116,10 +138,13 @@ export function categoryOf(type) {
 
 /**
  * Returns the category definition ({ label, description, types }) for
- * the given category key, or null when the key is unknown.
+ * the given category key. Accepts both canonical names (definitional)
+ * and aliases from earlier glossarist-js versions (conceptInstance,
+ * versioning) for backward compatibility.
  */
 export function categoryDefinition(categoryKey) {
-  return RELATION_CATEGORIES[categoryKey] ?? null;
+  const canonical = _CATEGORY_ALIASES[categoryKey] ?? categoryKey;
+  return RELATION_CATEGORIES[canonical] ?? null;
 }
 
 /**

package/src/models/relation-colors.js

@@ -18,8 +18,7 @@ export const RELATION_COLOR_DEFAULTS = Object.freeze({
     spatiotemporal: { light: '#0D9488', dark: '#5EEAD4' },
     lexical:        { light: '#D97706', dark: '#FBBF24' },
     mapping:        { light: '#2563EB', dark: '#93BBFD' },
-    conceptInstance:{ light: '#65A30D', dark: '#A3E635' },
-    versioning:     { light: '#9333EA', dark: '#C4B5FD' },
+    definitional:   { light: '#65A30D', dark: '#A3E635' },
   }),
 
   // Per-type overrides. Use the same { light, dark } shape. Keys are

package/src/rdf/agents-emitter.js

@@ -0,0 +1,130 @@
+// Agents emitter — emits foaf:Person / prov:Organization from
+// contributor declarations. Mirrors concept-browser's agents-emitter.ts.
+//
+// Each contributor becomes a foaf:Person + prov:Person + prov:Agent
+// with foaf:name, optional foaf:mbox (mailto link), rdfs:seeAlso (url).
+// Their organization (when provided) becomes a foaf:Organization +
+// prov:Organization, and the person is linked via prov:actedOnBehalfOf.
+
+import { namedNode, literal, quad } from './terms.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 = {
+  Person: `${PROV_NS}Person`,
+  Organization: `${PROV_NS}Organization`,
+  Agent: `${PROV_NS}Agent`,
+  actedOnBehalfOf: `${PROV_NS}actedOnBehalfOf`,
+};
+const FOAF = {
+  Person: `${FOAF_NS}Person`,
+  Organization: `${FOAF_NS}Organization`,
+  name: `${FOAF_NS}name`,
+  mbox: `${FOAF_NS}mbox`,
+};
+const DCTERMS = {
+  description: `${DCTERMS_NS}description`,
+};
+const RDFS = {
+  seeAlso: `${RDFS_NS}seeAlso`,
+};
+
+const DEFAULT_AGENT_BASE = 'https://glossarist.org/agent';
+const DEFAULT_ORG_BASE = 'https://glossarist.org/org';
+
+/**
+ * @typedef {Object} Contributor
+ * @property {string} name
+ * @property {string} [role]
+ * @property {string} [organization]
+ * @property {string} [url]
+ * @property {string} [email]
+ */
+/**
+ * @typedef {Contributor & { slug: string, agentIri: string }} AgentInput
+ */
+
+/**
+ * Slugify a name for IRIs. Lowercase, ASCII, hyphenated.
+ */
+export function slugify(input) {
+  return String(input)
+    .toLowerCase()
+    .normalize('NFKD')
+    .replace(/[̀-ͯ]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+/**
+ * Builds AgentInput records from raw contributor declarations.
+ * Useful for callers that want to inspect the IRIs before emission.
+ */
+export function agentsFromContributors(contributors, agentBase = DEFAULT_AGENT_BASE) {
+  return (contributors ?? []).map(c => {
+    const slug = slugify(c.name);
+    return {
+      slug,
+      name: c.name,
+      role: c.role,
+      organization: c.organization,
+      url: c.url,
+      email: c.email,
+      agentIri: `${agentBase}/${slug}`,
+    };
+  });
+}
+
+/**
+ * Emits foaf:Person + prov:Organization quads for a list of agents.
+ *
+ * Returns a generator of quads AND the set of unique person and
+ * organization IRIs emitted. Organizations are deduplicated — the
+ * same org across multiple contributors is emitted once.
+ *
+ * @param {readonly AgentInput[]} agents
+ * @param {Object} [options]
+ * @param {string} [options.orgBase] — default https://glossarist.org/org
+ * @returns {Generator<Quad, void, unknown>}
+ */
+export function* agentsToQuads(agents, options = {}) {
+  const orgBase = options.orgBase ?? DEFAULT_ORG_BASE;
+  const emittedOrgs = new Set();
+
+  for (const a of agents ?? []) {
+    const person = namedNode(a.agentIri);
+    yield quad(person, namedNode(RDF_TYPE), namedNode(FOAF.Person));
+    yield quad(person, namedNode(RDF_TYPE), namedNode(PROV.Person));
+    yield quad(person, namedNode(RDF_TYPE), namedNode(PROV.Agent));
+    yield quad(person, namedNode(FOAF.name), literal(a.name));
+
+    if (a.email) {
+      yield quad(person, namedNode(FOAF.mbox), namedNode(`mailto:${a.email}`));
+    }
+    if (a.url) {
+      yield quad(person, namedNode(RDFS.seeAlso), namedNode(a.url));
+    }
+    if (a.role) {
+      yield quad(person, namedNode(DCTERMS.description), literal(a.role));
+    }
+
+    if (a.organization) {
+      const orgSlug = slugify(a.organization);
+      const orgIri = `${orgBase}/${orgSlug}`;
+      yield quad(person, namedNode(PROV.actedOnBehalfOf), namedNode(orgIri));
+
+      if (!emittedOrgs.has(orgIri)) {
+        emittedOrgs.add(orgIri);
+        const org = namedNode(orgIri);
+        yield quad(org, namedNode(RDF_TYPE), namedNode(FOAF.Organization));
+        yield quad(org, namedNode(RDF_TYPE), namedNode(PROV.Organization));
+        yield quad(org, namedNode(RDF_TYPE), namedNode(PROV.Agent));
+        yield quad(org, namedNode(FOAF.name), literal(a.organization));
+      }
+    }
+  }
+}

package/src/rdf/bibliography-emitter.js

@@ -0,0 +1,120 @@
+// Bibliography emitter — emits dcterms:BibliographicResource per
+// bibliography entry. Mirrors concept-browser's bibliography-emitter.ts.
+//
+// Each entry becomes a typed resource with:
+// - dcterms:identifier (the entry id)
+// - dcterms:bibliographicCitation (the reference string)
+// - dcterms:title (optional)
+// - foaf:page (optional link)
+// - dcterms:type (optional, value URIs from gloss:bibtype/*)
+// - dcterms:isPartOf (parent dataset)
+
+import { namedNode, literal, quad } from './terms.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';
+
+const DCTERMS = {
+  BibliographicResource: `${DCTERMS_NS}BibliographicResource`,
+  identifier: `${DCTERMS_NS}identifier`,
+  bibliographicCitation: `${DCTERMS_NS}bibliographicCitation`,
+  title: `${DCTERMS_NS}title`,
+  type: `${DCTERMS_NS}type`,
+  isPartOf: `${DCTERMS_NS}isPartOf`,
+};
+const FOAF = {
+  page: `${FOAF_NS}page`,
+};
+
+const DEFAULT_BASE_URI = 'https://glossarist.org';
+
+/**
+ * @typedef {Object} BibliographyEntry
+ * @property {string} id
+ * @property {string} reference
+ * @property {string} [title]
+ * @property {string} [link]
+ * @property {string} [type]
+ */
+/**
+ * @typedef {Object} BibliographyInput
+ * @property {string} registerId
+ * @property {readonly BibliographyEntry[]} entries
+ * @property {string} [baseUri]
+ */
+
+/**
+ * Returns the canonical IRI for a bibliography entry.
+ *
+ * @param {string} registerId
+ * @param {string} entryId
+ * @param {string} [baseUri]
+ */
+export function bibliographyEntryIri(registerId, entryId, baseUri = DEFAULT_BASE_URI) {
+  return `${baseUri}/${registerId}/bib/${entryId}`;
+}
+
+/**
+ * Emits dcterms:BibliographicResource quads for each entry. Entries
+ * without an id or reference are skipped (matches concept-browser).
+ *
+ * @param {BibliographyInput} input
+ * @returns {Generator<Quad, void, unknown>}
+ */
+export function* bibliographyToQuads(input) {
+  const baseUri = input.baseUri ?? DEFAULT_BASE_URI;
+  const parentIri = `${baseUri}/${input.registerId}/`;
+
+  for (const entry of input.entries ?? []) {
+    if (!entry.id || !entry.reference) continue;
+    const entryIri = bibliographyEntryIri(input.registerId, entry.id, baseUri);
+    const e = namedNode(entryIri);
+
+    yield quad(e, namedNode(RDF_TYPE), namedNode(DCTERMS.BibliographicResource));
+    yield quad(e, namedNode(DCTERMS.identifier), literal(entry.id));
+    yield quad(e, namedNode(DCTERMS.bibliographicCitation), literal(entry.reference));
+    if (entry.title) {
+      yield quad(e, namedNode(DCTERMS.title), literal(entry.title));
+    }
+    if (entry.link) {
+      yield quad(e, namedNode(FOAF.page), namedNode(entry.link));
+    }
+    if (entry.type) {
+      yield quad(e, namedNode(DCTERMS.type), namedNode(`${GLOSS_NS}bibtype/${entry.type}`));
+    }
+    yield quad(e, namedNode(DCTERMS.isPartOf), namedNode(parentIri));
+  }
+}
+
+/**
+ * Normalizes raw bibliography data from a v3 YAML bibliography file.
+ * Accepts both shapes:
+ *   - { bibliography: [...] }
+ *   - { <id>: { ... }, <id>: { ... } }
+ *
+ * Returns a flat list of BibliographyEntry objects with explicit ids.
+ */
+export function normalizeBibliographyData(raw) {
+  if (!raw || typeof raw !== 'object') return [];
+  if (Array.isArray(raw.bibliography)) {
+    return raw.bibliography.map(e => entryFromV3(e));
+  }
+  const entries = [];
+  for (const [id, value] of Object.entries(raw)) {
+    if (!value || typeof value !== 'object') continue;
+    entries.push(entryFromV3(value, id));
+  }
+  return entries;
+}
+
+function entryFromV3(e, fallbackId) {
+  return {
+    id: e.id ?? fallbackId ?? '',
+    reference: e.reference ?? '',
+    title: e.title,
+    link: e.link,
+    type: e.type,
+  };
+}

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

@@ -0,0 +1,127 @@
+// Build activity emitter — emits prov:Activity per build run.
+// Mirrors concept-browser's build-activity-emitter.ts.
+//
+// Models a single CI build as a prov:Activity with:
+// - prov:StartingPoint and prov:EndingPoint time bounds
+// - prov:used links to the git commit, the build tool (prov:SoftwareAgent),
+//   and each dataset register
+// - gloss:conceptCount for the build output
+// - prov:wasAssociatedWith for the CI bot agent
+
+import { namedNode, literal, quad } from './terms.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 = {
+  Activity: `${PROV_NS}Activity`,
+  StartingPoint: `${PROV_NS}StartingPoint`,
+  EndingPoint: `${PROV_NS}EndingPoint`,
+  Entity: `${PROV_NS}Entity`,
+  SoftwareAgent: `${PROV_NS}SoftwareAgent`,
+  Agent: `${PROV_NS}Agent`,
+  Person: `${PROV_NS}Person`,
+  generatedAtTime: `${PROV_NS}generatedAtTime`,
+  atTime: `${PROV_NS}atTime`,
+  used: `${PROV_NS}used`,
+  wasAssociatedWith: `${PROV_NS}wasAssociatedWith`,
+  version: `${PROV_NS}version`,
+};
+const DCTERMS = {
+  identifier: `${DCTERMS_NS}identifier`,
+  description: `${DCTERMS_NS}description`,
+};
+const FOAF = {
+  Person: `${FOAF_NS}Person`,
+};
+const GLOSS = {
+  conceptCount: `${GLOSS_NS}conceptCount`,
+};
+const XSD_DATE_TIME = `${XSD_NS}dateTime`;
+const XSD_INTEGER = `${XSD_NS}integer`;
+
+/**
+ * @typedef {Object} BuildActivityInput
+ * @property {string} runId
+ * @property {string} startedAt — ISO date-time
+ * @property {string} endedAt — ISO date-time
+ * @property {string} [gitSha]
+ * @property {string} [gitBranch]
+ * @property {string} toolId
+ * @property {string} toolVersion
+ * @property {readonly string[]} datasetRegisters
+ * @property {number} conceptCount
+ * @property {string} [associatedAgentIri]
+ * @property {string} [baseUri] — default https://glossarist.org
+ */
+
+/**
+ * Returns the canonical relative IRI for a build activity.
+ */
+export function buildActivityIri(input) {
+  return `activity/build/${input.runId}`;
+}
+
+/**
+ * Emits prov:Activity quads for one build run, including the
+ * starting/ending time bounds, the build tool as prov:SoftwareAgent,
+ * the git commit (when provided) as a prov:Entity, and each dataset
+ * register as a prov:used target.
+ *
+ * @param {BuildActivityInput} input
+ * @returns {Generator<Quad, void, unknown>}
+ */
+export function* buildActivityToQuads(input) {
+  const baseUri = input.baseUri ?? 'https://glossarist.org';
+  const activityIri = `${baseUri}/${buildActivityIri(input)}`;
+  const activity = namedNode(activityIri);
+
+  yield quad(activity, namedNode(RDF_TYPE), namedNode(PROV.Activity));
+  yield quad(activity, namedNode(PROV.generatedAtTime), literal(input.endedAt, namedNode(XSD_DATE_TIME)));
+
+  // StartingPoint and EndingPoint are sub-types of prov:TimeBound.
+  // Modeling them as separate resources lets consumers query exact
+  // start vs end without parsing date ranges.
+  const start = namedNode(`${activityIri}/start`);
+  yield quad(start, namedNode(RDF_TYPE), namedNode(PROV.StartingPoint));
+  yield quad(start, namedNode(PROV.atTime), literal(input.startedAt, namedNode(XSD_DATE_TIME)));
+
+  const end = namedNode(`${activityIri}/end`);
+  yield quad(end, namedNode(RDF_TYPE), namedNode(PROV.EndingPoint));
+  yield quad(end, namedNode(PROV.atTime), literal(input.endedAt, namedNode(XSD_DATE_TIME)));
+
+  if (input.gitSha) {
+    const commitIri = `${baseUri}/commit/${input.gitSha}`;
+    yield quad(activity, namedNode(PROV.used), namedNode(commitIri));
+    const commit = namedNode(commitIri);
+    yield quad(commit, namedNode(RDF_TYPE), namedNode(PROV.Entity));
+    if (input.gitBranch) {
+      yield quad(commit, namedNode(DCTERMS.description), literal(`branch: ${input.gitBranch}`));
+    }
+  }
+
+  const toolIri = `${baseUri}/tool/${input.toolId}/${input.toolVersion}`;
+  yield quad(activity, namedNode(PROV.used), namedNode(toolIri));
+  const tool = namedNode(toolIri);
+  yield quad(tool, namedNode(RDF_TYPE), namedNode(PROV.Entity));
+  yield quad(tool, namedNode(RDF_TYPE), namedNode(PROV.SoftwareAgent));
+  yield quad(tool, namedNode(DCTERMS.identifier), literal(input.toolVersion));
+  yield quad(tool, namedNode(PROV.version), literal(input.toolVersion));
+
+  for (const register of input.datasetRegisters ?? []) {
+    yield quad(activity, namedNode(PROV.used), namedNode(`${baseUri}/${register}/`));
+  }
+
+  yield quad(activity, namedNode(GLOSS.conceptCount), literal(String(input.conceptCount), namedNode(XSD_INTEGER)));
+
+  if (input.associatedAgentIri) {
+    yield quad(activity, namedNode(PROV.wasAssociatedWith), namedNode(input.associatedAgentIri));
+    const agent = namedNode(input.associatedAgentIri);
+    yield quad(agent, namedNode(RDF_TYPE), namedNode(PROV.Agent));
+    yield quad(agent, namedNode(RDF_TYPE), namedNode(FOAF.Person));
+  }
+}

package/src/rdf/dataset-emitter.js

@@ -0,0 +1,179 @@
+// Dataset emitter — emits dcat:Dataset + skos:ConceptScheme per
+// register. Mirrors concept-browser's dataset-emitter.ts.
+//
+// The dataset describes the vocabulary as a whole: title, description,
+// modified date, languages, distributions (Turtle/JSON-LD/YAML), top
+// concepts, sections, source repo, publisher, contact.
+//
+// Each section becomes a skos:Collection linked via skos:member to
+// its concept URIs and via gloss:hasParentSection / gloss:hasChildSection
+// to its relatives (the ontology declares these as owl:TransitiveProperty
+// for cascading section membership).
+
+import { namedNode, literal, quad } from './terms.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#';
+
+/**
+ * @typedef {Object} DatasetDistribution
+ * @property {string} id
+ * @property {string} title
+ * @property {string} mediaType
+ * @property {string} downloadUrl
+ * @property {number} [byteSize]
+ */
+/**
+ * @typedef {Object} DatasetSection
+ * @property {string} collectionIri
+ * @property {string} title
+ * @property {readonly string[]} memberUris
+ * @property {string} [parentCollectionIri]
+ * @property {readonly string[]} [childCollectionIris]
+ */
+/**
+ * @typedef {Object} DatasetEmitterInput
+ * @property {string} datasetIri
+ * @property {string} registerId
+ * @property {string} title
+ * @property {string} [description]
+ * @property {string} modified — ISO date (YYYY-MM-DD)
+ * @property {readonly string[]} languages
+ * @property {readonly DatasetDistribution[]} distributions
+ * @property {readonly string[]} topConceptUris
+ * @property {readonly DatasetSection[]} sections
+ * @property {string} [sourceRepoUrl]
+ * @property {string} [publisherIri]
+ * @property {string} [contactIri]
+ */
+
+const DCAT = {
+  Dataset: `${DCAT_NS}Dataset`,
+  ConceptScheme: `${SKOS_NS}ConceptScheme`,
+  Distribution: `${DCAT_NS}Distribution`,
+  Collection: `${SKOS_NS}Collection`,
+  mediaType: `${DCAT_NS}mediaType`,
+  downloadURL: `${DCAT_NS}downloadURL`,
+  byteSize: `${DCAT_NS}byteSize`,
+  distribution: `${DCAT_NS}distribution`,
+  contactPoint: `${DCAT_NS}contactPoint`,
+};
+const DCTERMS = {
+  title: `${DCTERMS_NS}title`,
+  description: `${DCTERMS_NS}description`,
+  modified: `${DCTERMS_NS}modified`,
+  identifier: `${DCTERMS_NS}identifier`,
+  language: `${DCTERMS_NS}language`,
+  publisher: `${DCTERMS_NS}publisher`,
+};
+const SKOS = {
+  hasTopConcept: `${SKOS_NS}hasTopConcept`,
+  member: `${SKOS_NS}member`,
+};
+const PROV = {
+  wasDerivedFrom: `${PROV_NS}wasDerivedFrom`,
+};
+const GLOSS = {
+  hasParentSection: `${GLOSS_NS}hasParentSection`,
+  hasChildSection: `${GLOSS_NS}hasChildSection`,
+};
+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
+ * metadata, plus its distributions, sections, and top concepts.
+ *
+ * @param {DatasetEmitterInput} input
+ * @returns {Generator<Quad, void, unknown>}
+ */
+export function* datasetToQuads(input) {
+  const ds = namedNode(input.datasetIri);
+
+  yield quad(ds, namedNode(RDF_TYPE), namedNode(DCAT.Dataset));
+  yield quad(ds, namedNode(RDF_TYPE), namedNode(DCAT.ConceptScheme));
+  yield quad(ds, namedNode(DCTERMS.title), literal(input.title));
+  if (input.description) {
+    yield quad(ds, namedNode(DCTERMS.description), literal(input.description));
+  }
+  yield quad(ds, namedNode(DCTERMS.modified), literal(input.modified, namedNode(XSD_DATE)));
+  yield quad(ds, namedNode(DCTERMS.identifier), literal(input.registerId));
+
+  for (const lang of input.languages ?? []) {
+    const langIri = `http://id.loc.gov/vocabulary/iso639-1/${lang}`;
+    yield quad(ds, namedNode(DCTERMS.language), namedNode(langIri));
+  }
+
+  for (const dist of input.distributions ?? []) {
+    yield* distributionToQuads(ds, dist);
+  }
+
+  for (const conceptUri of input.topConceptUris ?? []) {
+    yield quad(ds, namedNode(SKOS.hasTopConcept), namedNode(conceptUri));
+  }
+
+  if (input.sourceRepoUrl) {
+    yield quad(ds, namedNode(PROV.wasDerivedFrom), namedNode(input.sourceRepoUrl));
+  }
+  if (input.publisherIri) {
+    yield quad(ds, namedNode(DCTERMS.publisher), namedNode(input.publisherIri));
+  }
+  if (input.contactIri) {
+    yield quad(ds, namedNode(DCAT.contactPoint), namedNode(input.contactIri));
+  }
+
+  for (const section of input.sections ?? []) {
+    yield* sectionToQuads(section);
+  }
+}
+
+function* distributionToQuads(ds, dist) {
+  // Distributions are blank nodes — they don't have stable identity
+  // outside their parent dataset.
+  const distSubject = namedNode(`_:b${deterministicId('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));
+  yield quad(distSubject, namedNode(DCAT.mediaType), literal(dist.mediaType));
+  yield quad(distSubject, namedNode(DCAT.downloadURL), namedNode(dist.downloadUrl));
+  if (dist.byteSize != null) {
+    yield quad(distSubject, namedNode(DCAT.byteSize), literal(String(dist.byteSize), namedNode(XSD_INTEGER)));
+  }
+}
+
+function* sectionToQuads(section) {
+  const coll = namedNode(section.collectionIri);
+  yield quad(coll, namedNode(RDF_TYPE), namedNode(DCAT.Collection));
+  yield quad(coll, namedNode(DCTERMS.title), literal(section.title));
+  for (const member of section.memberUris ?? []) {
+    yield quad(coll, namedNode(SKOS.member), namedNode(member));
+  }
+  if (section.parentCollectionIri) {
+    yield quad(coll, namedNode(GLOSS.hasParentSection), namedNode(section.parentCollectionIri));
+  }
+  for (const child of section.childCollectionIris ?? []) {
+    yield quad(coll, namedNode(GLOSS.hasChildSection), namedNode(child));
+  }
+}
+
+// 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');
+}

package/src/rdf/group-emitter.js

@@ -0,0 +1,132 @@
+// Group emitter — emits dcat:DatasetSeries (lineage) or dcat:Catalog
+// (topic/family/collection) for dataset groups. Mirrors concept-browser's
+// group-emitter.ts.
+//
+// A lineage group (editions of the same vocabulary) is rendered as
+// dcat:DatasetSeries with hasVersion links to each member edition.
+// The current edition is linked via hasCurrentVersion.
+//
+// Other group kinds (topic, family, collection) are rendered as
+// dcat:Catalog with dcat:dataset links to each member.
+//
+// Both kinds are also typed as skos:ConceptScheme for SKOS interop.
+
+import { namedNode, literal, quad } from './terms.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';
+
+const DCAT = {
+  DatasetSeries: `${DCAT_NS}DatasetSeries`,
+  Catalog: `${DCAT_NS}Catalog`,
+  ConceptScheme: `${SKOS_NS}ConceptScheme`,
+  hasVersion: `${DCAT_NS}hasVersion`,
+  hasCurrentVersion: `${DCAT_NS}hasCurrentVersion`,
+  dataset: `${DCAT_NS}dataset`,
+  theme: `${DCAT_NS}theme`,
+  keyword: `${DCAT_NS}keyword`,
+  contactPoint: `${DCAT_NS}contactPoint`,
+};
+const DCTERMS = {
+  title: `${DCTERMS_NS}title`,
+  description: `${DCTERMS_NS}description`,
+  identifier: `${DCTERMS_NS}identifier`,
+  subject: `${DCTERMS_NS}subject`,
+  publisher: `${DCTERMS_NS}publisher`,
+};
+const PROV = {
+  wasDerivedFrom: `${PROV_NS}wasDerivedFrom`,
+};
+
+/**
+ * @typedef {'lineage' | 'topic' | 'family' | 'collection' | 'default'} DatasetGroupKind
+ */
+/**
+ * @typedef {Object} GroupEmitInput
+ * @property {string} groupId
+ * @property {string} groupIri
+ * @property {DatasetGroupKind} kind
+ * @property {string} title
+ * @property {string} [description]
+ * @property {readonly string[]} memberIris
+ * @property {string} [currentMemberIri]
+ * @property {string} [subject]
+ * @property {readonly string[]} [themes]
+ * @property {readonly string[]} [keywords]
+ * @property {string} [publisher]
+ * @property {string} [contact]
+ * @property {string} [sourceRepo]
+ */
+
+// Returns the RDF class IRIs for a group kind. Empty for 'default'
+// (no semantics — group is purely a presentation concern).
+function rdfClassesForKind(kind) {
+  switch (kind) {
+    case 'lineage': return [DCAT.DatasetSeries, DCAT.ConceptScheme];
+    case 'topic':
+    case 'family':
+    case 'collection': return [DCAT.Catalog, DCAT.ConceptScheme];
+    default: return [];
+  }
+}
+
+/**
+ * Emits dcat:DatasetSeries or dcat:Catalog quads for one group.
+ *
+ * Returns an empty generator (no quads) for 'default' kind — those
+ * groups have no RDF semantics.
+ *
+ * @param {GroupEmitInput} input
+ * @returns {Generator<Quad, void, unknown>}
+ */
+export function* groupToQuads(input) {
+  const classes = rdfClassesForKind(input.kind);
+  if (classes.length === 0) return;
+
+  const g = namedNode(input.groupIri);
+
+  for (const cls of classes) {
+    yield quad(g, namedNode(RDF_TYPE), namedNode(cls));
+  }
+
+  yield quad(g, namedNode(DCTERMS.title), literal(input.title));
+  yield quad(g, namedNode(DCTERMS.identifier), literal(input.groupId));
+  if (input.description) {
+    yield quad(g, namedNode(DCTERMS.description), literal(input.description));
+  }
+  if (input.subject) {
+    yield quad(g, namedNode(DCTERMS.subject), literal(input.subject));
+  }
+  for (const theme of input.themes ?? []) {
+    yield quad(g, namedNode(DCAT.theme), namedNode(theme));
+  }
+  for (const kw of input.keywords ?? []) {
+    yield quad(g, namedNode(DCAT.keyword), literal(kw));
+  }
+  if (input.publisher) {
+    yield quad(g, namedNode(DCTERMS.publisher), namedNode(input.publisher));
+  }
+  if (input.contact) {
+    yield quad(g, namedNode(DCAT.contactPoint), namedNode(input.contact));
+  }
+  if (input.sourceRepo) {
+    yield quad(g, namedNode(PROV.wasDerivedFrom), namedNode(input.sourceRepo));
+  }
+
+  if (input.kind === 'lineage') {
+    for (const memberIri of input.memberIris ?? []) {
+      yield quad(g, namedNode(DCAT.hasVersion), namedNode(memberIri));
+    }
+    if (input.currentMemberIri) {
+      yield quad(g, namedNode(DCAT.hasCurrentVersion), namedNode(input.currentMemberIri));
+    }
+  } else {
+    for (const memberIri of input.memberIris ?? []) {
+      yield quad(g, namedNode(DCAT.dataset), namedNode(memberIri));
+    }
+  }
+}

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

@@ -0,0 +1,77 @@
+// Image variant emitter — emits foaf:Image per format/language variant
+// of a dataset figure. Mirrors concept-browser's image-variant-emitter.ts.
+//
+// Each variant becomes a foaf:Image with:
+// - dcterms:format (MIME type)
+// - dcterms:language (when localized)
+// - dcat:byteSize (when known)
+// - dcat:downloadURL (canonical download)
+
+import { namedNode, literal, quad } from './terms.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 = {
+  Image: `${FOAF_NS}Image`,
+};
+const DCTERMS = {
+  format: `${DCTERMS_NS}format`,
+  language: `${DCTERMS_NS}language`,
+};
+const DCAT = {
+  byteSize: `${DCAT_NS}byteSize`,
+  downloadURL: `${DCAT_NS}downloadURL`,
+};
+const XSD_INTEGER = `${XSD_NS}integer`;
+
+const DEFAULT_BASE_URI = 'https://glossarist.org';
+
+/**
+ * @typedef {'svg' | 'png' | 'webp' | 'jpg' | 'gif'} ImageFormat
+ */
+/**
+ * @typedef {Object} ImageVariantInput
+ * @property {string} registerId
+ * @property {string} figureId
+ * @property {string} [lang]
+ * @property {ImageFormat} format
+ * @property {number} [byteSize]
+ * @property {string} downloadUrl
+ */
+
+const MIME_BY_FORMAT = Object.freeze({
+  svg: 'image/svg+xml',
+  png: 'image/png',
+  webp: 'image/webp',
+  jpg: 'image/jpeg',
+  gif: 'image/gif',
+});
+
+/**
+ * Returns the canonical IRI for an image variant. Includes the lang
+ * segment when the variant is localized, otherwise omits it.
+ */
+export function imageVariantIri(input, baseUri = DEFAULT_BASE_URI) {
+  const langSuffix = input.lang ? `${input.lang}.` : '';
+  return `${baseUri}/${input.registerId}/image/${input.figureId}/${langSuffix}${input.format}`;
+}
+
+/**
+ * Emits foaf:Image quads for one image variant.
+ */
+export function* imageVariantToQuads(input, baseUri = DEFAULT_BASE_URI) {
+  const img = namedNode(imageVariantIri(input, baseUri));
+  yield quad(img, namedNode(RDF_TYPE), namedNode(FOAF.Image));
+  yield quad(img, namedNode(DCTERMS.format), literal(MIME_BY_FORMAT[input.format] ?? 'application/octet-stream'));
+  if (input.lang) {
+    yield quad(img, namedNode(DCTERMS.language), literal(input.lang));
+  }
+  if (input.byteSize != null) {
+    yield quad(img, namedNode(DCAT.byteSize), literal(String(input.byteSize), namedNode(XSD_INTEGER)));
+  }
+  yield quad(img, namedNode(DCAT.downloadURL), namedNode(input.downloadUrl));
+}

package/src/rdf/index.d.ts

@@ -97,6 +97,158 @@ 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>;
 
+// Vocabulary emitter (SKOS ConceptSchemes for enumeration IRIs)
+export interface VocabTerm {
+  iri: string;
+  label: string;
+}
+export interface VocabScheme {
+  schemeIri: string;
+  label: string;
+  terms: readonly VocabTerm[];
+}
+export declare function resolveIri(iri: string): string;
+export declare function vocabularySchemeToQuads(scheme: VocabScheme): Generator<Quad, void, unknown>;
+export declare function vocabularyToQuads(schemes: readonly VocabScheme[]): Generator<Quad, void, unknown>;
+
+// Dataset emitter (dcat:Dataset + skos:ConceptScheme per register)
+export interface DatasetDistribution {
+  id: string;
+  title: string;
+  mediaType: string;
+  downloadUrl: string;
+  byteSize?: number;
+}
+export interface DatasetSection {
+  collectionIri: string;
+  title: string;
+  memberUris: readonly string[];
+  parentCollectionIri?: string;
+  childCollectionIris?: readonly string[];
+}
+export interface DatasetEmitterInput {
+  datasetIri: string;
+  registerId: string;
+  title: string;
+  description?: string;
+  modified: string;
+  languages: readonly string[];
+  distributions: readonly DatasetDistribution[];
+  topConceptUris: readonly string[];
+  sections: readonly DatasetSection[];
+  sourceRepoUrl?: string;
+  publisherIri?: string;
+  contactIri?: string;
+}
+export declare function datasetToQuads(input: DatasetEmitterInput): Generator<Quad, void, unknown>;
+
+// Group emitter (dcat:DatasetSeries or dcat:Catalog)
+export type DatasetGroupKind = 'lineage' | 'topic' | 'family' | 'collection' | 'default';
+export interface GroupEmitInput {
+  groupId: string;
+  groupIri: string;
+  kind: DatasetGroupKind;
+  title: string;
+  description?: string;
+  memberIris: readonly string[];
+  currentMemberIri?: string;
+  subject?: string;
+  themes?: readonly string[];
+  keywords?: readonly string[];
+  publisher?: string;
+  contact?: string;
+  sourceRepo?: string;
+}
+export declare function groupToQuads(input: GroupEmitInput): Generator<Quad, void, unknown>;
+
+// Bibliography emitter (dcterms:BibliographicResource)
+export interface BibliographyEntry {
+  id: string;
+  reference: string;
+  title?: string;
+  link?: string;
+  type?: string;
+}
+export interface BibliographyInput {
+  registerId: string;
+  entries: readonly BibliographyEntry[];
+  baseUri?: string;
+}
+export declare function bibliographyEntryIri(registerId: string, entryId: string, baseUri?: string): string;
+export declare function bibliographyToQuads(input: BibliographyInput): Generator<Quad, void, unknown>;
+export declare function normalizeBibliographyData(raw: unknown): BibliographyEntry[];
+
+// Build activity emitter (prov:Activity per build run)
+export interface BuildActivityInput {
+  runId: string;
+  startedAt: string;
+  endedAt: string;
+  gitSha?: string;
+  gitBranch?: string;
+  toolId: string;
+  toolVersion: string;
+  datasetRegisters: readonly string[];
+  conceptCount: number;
+  associatedAgentIri?: string;
+  baseUri?: string;
+}
+export declare function buildActivityIri(input: Pick<BuildActivityInput, 'runId'>): string;
+export declare function buildActivityToQuads(input: BuildActivityInput): Generator<Quad, void, unknown>;
+
+// Agents emitter (foaf:Person / prov:Organization)
+export interface Contributor {
+  name: string;
+  role?: string;
+  organization?: string;
+  url?: string;
+  email?: string;
+}
+export interface AgentInput extends Contributor {
+  slug: string;
+  agentIri: string;
+}
+export declare function slugify(input: string): string;
+export declare function agentsFromContributors(contributors: readonly Contributor[], agentBase?: string): AgentInput[];
+export declare function agentsToQuads(agents: readonly AgentInput[], options?: { orgBase?: string }): Generator<Quad, void, unknown>;
+
+// Version emitter (prov:Entity version chain)
+export interface DatasetVersionInput {
+  registerId: string;
+  version: string;
+  versionIri: string;
+  datasetIri: string;
+  generatedAt: string;
+  previousVersionIri?: string;
+  changeSummary?: string;
+  associatedAgentIri?: string;
+}
+export interface VersionHistoryEntry {
+  version: string;
+  generatedAt: string;
+  changeSummary?: string;
+}
+export interface VersionEmitAllInput {
+  registerId: string;
+  datasetIri: string;
+  versions: readonly VersionHistoryEntry[];
+  associatedAgentIri?: string;
+}
+export declare function versionToQuads(input: DatasetVersionInput): Generator<Quad, void, unknown>;
+export declare function versionHistoryToQuads(input: VersionEmitAllInput): Generator<Quad, void, unknown>;
+
+// Image variant emitter (foaf:Image per format/language variant)
+export type ImageFormat = 'svg' | 'png' | 'webp' | 'jpg' | 'gif';
+export interface ImageVariantInput {
+  registerId: string;
+  figureId: string;
+  lang?: string;
+  format: ImageFormat;
+  byteSize?: number;
+  downloadUrl: string;
+}
+export declare function imageVariantIri(input: ImageVariantInput, baseUri?: string): string;
+export declare function imageVariantToQuads(input: ImageVariantInput, baseUri?: string): Generator<Quad, void, unknown>;
+
 export declare function collectQuads(quadsIterable: Iterable<Quad>): Quad[];
 
 export interface WriteTurtleOptions {

package/src/rdf/index.js

@@ -22,6 +22,18 @@ export {
   nonVerbalEntityToQuads,
   nonVerbalEntityUri,
 } from './gloss-non-verbal-rep.js';
+export {
+  vocabularySchemeToQuads,
+  vocabularyToQuads,
+  resolveIri,
+} from './vocabulary-emitter.js';
+export { datasetToQuads } from './dataset-emitter.js';
+export { groupToQuads } from './group-emitter.js';
+export { bibliographyToQuads, bibliographyEntryIri, normalizeBibliographyData } from './bibliography-emitter.js';
+export { buildActivityIri, buildActivityToQuads } from './build-activity-emitter.js';
+export { agentsFromContributors, agentsToQuads, slugify } from './agents-emitter.js';
+export { versionToQuads, versionHistoryToQuads } from './version-emitter.js';
+export { imageVariantIri, imageVariantToQuads } from './image-variant-emitter.js';
 export {
   collectQuads,
   writeTurtle,

package/src/rdf/version-emitter.js

@@ -0,0 +1,96 @@
+// Version emitter — emits prov:Entity version chain per dataset.
+// Mirrors concept-browser's version-emitter.ts.
+//
+// Each version of a dataset becomes a prov:Entity typed resource with:
+// - dcterms:isVersionOf → the dataset
+// - prov:wasRevisionOf → previous version (when provided)
+// - prov:generatedAtTime (xsd:dateTime)
+// - dcterms:description (optional change summary)
+// - prov:wasAssociatedWith (optional agent)
+
+import { namedNode, literal, quad } from './terms.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 = {
+  Entity: `${PROV_NS}Entity`,
+  wasRevisionOf: `${PROV_NS}wasRevisionOf`,
+  generatedAtTime: `${PROV_NS}generatedAtTime`,
+  wasAssociatedWith: `${PROV_NS}wasAssociatedWith`,
+};
+const DCTERMS = {
+  isVersionOf: `${DCTERMS_NS}isVersionOf`,
+  description: `${DCTERMS_NS}description`,
+};
+const XSD_DATE_TIME = `${XSD_NS}dateTime`;
+
+/**
+ * @typedef {Object} DatasetVersionInput
+ * @property {string} registerId
+ * @property {string} version
+ * @property {string} versionIri
+ * @property {string} datasetIri
+ * @property {string} generatedAt — ISO date-time
+ * @property {string} [previousVersionIri]
+ * @property {string} [changeSummary]
+ * @property {string} [associatedAgentIri]
+ */
+/**
+ * @typedef {Object} VersionHistoryEntry
+ * @property {string} version
+ * @property {string} generatedAt
+ * @property {string} [changeSummary]
+ */
+/**
+ * @typedef {Object} VersionEmitAllInput
+ * @property {string} registerId
+ * @property {string} datasetIri
+ * @property {readonly VersionHistoryEntry[]} versions
+ * @property {string} [associatedAgentIri]
+ */
+
+/**
+ * Emits a single prov:Entity version with its provenance chain.
+ */
+export function* versionToQuads(input) {
+  const v = namedNode(input.versionIri);
+  yield quad(v, namedNode(RDF_TYPE), namedNode(PROV.Entity));
+  yield quad(v, namedNode(DCTERMS.isVersionOf), namedNode(input.datasetIri));
+  if (input.previousVersionIri) {
+    yield quad(v, namedNode(PROV.wasRevisionOf), namedNode(input.previousVersionIri));
+  }
+  yield quad(v, namedNode(PROV.generatedAtTime), literal(input.generatedAt, namedNode(XSD_DATE_TIME)));
+  if (input.changeSummary) {
+    yield quad(v, namedNode(DCTERMS.description), literal(input.changeSummary));
+  }
+  if (input.associatedAgentIri) {
+    yield quad(v, namedNode(PROV.wasAssociatedWith), namedNode(input.associatedAgentIri));
+  }
+}
+
+/**
+ * Emits the full version history chain. Versions are linked in
+ * sequence via prov:wasRevisionOf (newest → previous → ... → oldest).
+ *
+ * The version IRI is constructed as `${datasetIri}versions/${version}`.
+ */
+export function* versionHistoryToQuads(input) {
+  let previousIri;
+  for (const v of input.versions ?? []) {
+    const versionIri = `${input.datasetIri}versions/${v.version}`;
+    yield* versionToQuads({
+      registerId: input.registerId,
+      version: v.version,
+      versionIri,
+      datasetIri: input.datasetIri,
+      generatedAt: v.generatedAt,
+      previousVersionIri: previousIri,
+      changeSummary: v.changeSummary,
+      associatedAgentIri: input.associatedAgentIri,
+    });
+    previousIri = versionIri;
+  }
+}

package/src/rdf/vocabulary-emitter.js

@@ -0,0 +1,87 @@
+// Vocabulary graph emitter — emits SKOS ConceptSchemes for the
+// enumeration IRIs that glossarist emits in instance data
+// (gloss:status/*, gloss:entstatus/*, gloss:norm/*, gloss:srcstatus/*,
+// gloss:srctype/*, gloss:datetype/*, gloss:rel/*, etc.).
+//
+// Each enumeration value becomes a skos:Concept in its corresponding
+// skos:ConceptScheme. The scheme uses skos:hasTopConcept to link to
+// its members; members use skos:inScheme to link back.
+//
+// Accepts the schemes data as a plain object — no fs deps, browser-safe.
+// Callers can load the JSON file themselves (Node) or construct the
+// data inline. CURIEs in the input are resolved to absolute IRIs via
+// PREFIXES.
+
+import { namedNode, literal, quad } from './terms.js';
+import { PREFIXES } from './predicates.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;
+
+/**
+ * @typedef {Object} VocabTerm
+ * @property {string} iri — absolute IRI or CURIE (resolved via PREFIXES)
+ * @property {string} label — human-readable label (typically English)
+ */
+/**
+ * @typedef {Object} VocabScheme
+ * @property {string} schemeIri — absolute IRI or CURIE
+ * @property {string} label
+ * @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.
+ *
+ * @param {VocabScheme} scheme
+ * @returns {Generator<Quad, void, unknown>}
+ */
+export function* vocabularySchemeToQuads(scheme) {
+  const schemeIri = resolveIri(scheme.schemeIri);
+  const schemeSubject = namedNode(schemeIri);
+
+  yield quad(schemeSubject, namedNode(RDF_TYPE), namedNode(`${SKOS_NS}ConceptScheme`));
+  yield quad(schemeSubject, namedNode(RDF_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(`${SKOS_NS}inScheme`), schemeSubject);
+    yield quad(schemeSubject, namedNode(`${SKOS_NS}hasTopConcept`), termSubject);
+  }
+}
+
+/**
+ * Emits SKOS ConceptScheme + Concept quads for many schemes.
+ *
+ * @param {readonly VocabScheme[]} schemes
+ * @returns {Generator<Quad, void, unknown>}
+ */
+export function* vocabularyToQuads(schemes) {
+  for (const scheme of schemes ?? []) {
+    yield* vocabularySchemeToQuads(scheme);
+  }
+}
+
+// Re-exported for callers that want to resolve CURIEs themselves.
+export { resolveIri };