@glossarist/concept-browser 0.7.51 → 0.7.53

package/scripts/generate-data.mjs

@@ -6,6 +6,12 @@ import { loadSiteConfig } from './load-site-config.mjs';
 import { getGroups } from './lib/concept-groups.mjs';
 import { consumeDatasetEntities } from './lib/build/non-verbal-consumer.mjs';
 import { copyImageAssets } from './lib/build/image-assets.mjs';
+import { buildDatasetTurtle } from './lib/dataset-turtle.mjs';
+import { buildActivityTurtle } from './lib/build-activity-turtle.mjs';
+import { buildVocabularyTurtle } from './lib/vocab-turtle.mjs';
+import { buildAgentsTurtle } from './lib/agents-turtle.mjs';
+import { buildVersionHistoryTurtle } from './lib/version-turtle.mjs';
+import { buildBibliographyTurtle } from './lib/bibliography-turtle.mjs';
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
 const ROOT = process.cwd();
 const PUBLIC = path.join(ROOT, 'public');
@@ -84,6 +90,83 @@ function writeJson(filePath, data) {
   fs.writeFileSync(filePath, JSON.stringify(data));
 }
 
+function writeDatasetRdf(register, manifest, concepts, refMaps, opts) {
+  const uriBase = refMaps?.uriBase ?? 'https://glossarist.org';
+  const datasetIri = `${uriBase}/${register}/`;
+  const topConceptUris = concepts
+    .slice(0, 32)
+    .map(c => `${uriBase}/${register}/concept/${c.id}`);
+
+  const sections = (manifest.sections ?? []).map(section => {
+    const sectionId = section.id ?? section.slug ?? section.title;
+    return {
+      collectionIri: `${uriBase}/${register}/section/${sectionId}`,
+      title: section.title ?? section.name ?? sectionId,
+      memberUris: (section.members ?? []).map(id => `${uriBase}/${register}/concept/${id}`),
+    };
+  });
+
+  const distributions = [
+    {
+      id: `${register}-ttl`,
+      title: 'Turtle distribution',
+      mediaType: 'text/turtle',
+      downloadUrl: `${uriBase}/data/${register}/${register}.ttl`,
+    },
+    {
+      id: `${register}-jsonld`,
+      title: 'JSON-LD distribution',
+      mediaType: 'application/ld+json',
+      downloadUrl: `${uriBase}/data/${register}/${register}.jsonld`,
+    },
+  ];
+
+  const ttl = buildDatasetTurtle({
+    datasetIri,
+    registerId: register,
+    title: manifest.title ?? register,
+    description: manifest.description,
+    modified: manifest.lastUpdated ?? new Date().toISOString().slice(0, 10),
+    languages: opts.languages ?? ['eng'],
+    distributions,
+    topConceptUris,
+    sections,
+    sourceRepoUrl: manifest.sourceRepoUrl,
+    publisherIri: manifest.publisher,
+    contactIri: manifest.contactPoint,
+  });
+  fs.writeFileSync(path.join(DATA, register, `${register}.ttl`), ttl);
+}
+
+function writeBuildActivity(conceptCount, datasetRegisters) {
+  const runId = process.env.GITHUB_RUN_ID
+    ? `${process.env.GITHUB_RUN_ID}-${process.env.GITHUB_RUN_ATTEMPT ?? '1'}`
+    : `local-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+  const startedAt = process.env.BUILD_STARTED_AT ?? new Date(Date.now() - 60_000).toISOString();
+  const endedAt = new Date().toISOString();
+  const gitSha = process.env.GITHUB_SHA ?? null;
+  const gitBranch = process.env.GITHUB_REF_NAME ?? null;
+  const pkgVersion = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')).version;
+  const agentIri = process.env.CI_BOT_AGENT_IRI ?? null;
+
+  const ttl = buildActivityTurtle({
+    runId,
+    startedAt,
+    endedAt,
+    gitSha,
+    gitBranch,
+    toolId: 'concept-browser',
+    toolVersion: pkgVersion,
+    datasetRegisters,
+    conceptCount,
+    associatedAgentIri: agentIri,
+  });
+  const activityDir = path.join(DATA, 'activity');
+  fs.mkdirSync(activityDir, { recursive: true });
+  fs.writeFileSync(path.join(activityDir, `${runId}.ttl`), ttl);
+  console.log(`Emitted build activity record: data/activity/${runId}.ttl`);
+}
+
 function termToDesignation(term) {
   const typeMap = {
     expression: 'gl:Expression',
@@ -1007,6 +1090,9 @@ async function processDataset(dir, register, opts) {
   if (opts.sections && opts.sections.length > 0) manifest.sections = opts.sections;
   writeJson(path.join(DATA, register, 'manifest.json'), manifest);
 
+  // Dataset-level RDF (WS J2/J5): dcat:Dataset + skos:ConceptScheme + skos:Collection per section.
+  writeDatasetRdf(register, manifest, concepts, refMaps, opts);
+
   // Copy bibliography.yaml → bibliography.json
   const bibPath = path.join(sourceRoot, 'bibliography.yaml');
   if (fs.existsSync(bibPath)) {
@@ -1522,3 +1608,53 @@ console.log(`\nDone! Generated data for ${total} concepts across ${registry.leng
 for (const [id, count] of Object.entries(counts)) {
   console.log(`  ${id}: ${count} concepts`);
 }
+
+writeBuildActivity(total, registry.map(r => r.id));
+
+fs.writeFileSync(path.join(DATA, '_vocab.ttl'), buildVocabularyTurtle());
+console.log('Emitted vocabulary graph: data/_vocab.ttl');
+
+const contributors = config.contributors ?? [];
+if (contributors.length > 0) {
+  fs.writeFileSync(path.join(DATA, 'agents.ttl'), buildAgentsTurtle(contributors));
+  console.log(`Emitted agents graph: data/agents.ttl (${contributors.length} contributors)`);
+}
+
+// Bibliography aggregation (K5): one bib.ttl per register from bibliography.json
+for (const ds of registry) {
+  const bibPath = path.join(DATA, ds.id, 'bibliography.json');
+  if (fs.existsSync(bibPath)) {
+    const bibJson = JSON.parse(fs.readFileSync(bibPath, 'utf8'));
+    const bibTtl = buildBibliographyTurtle(ds.id, bibJson);
+    fs.writeFileSync(path.join(DATA, ds.id, 'bib.ttl'), bibTtl);
+  }
+}
+
+const datasetVersions = registry.map(ds => ({
+  registerId: ds.id,
+  datasetIri: `${refMaps.uriBase}/${ds.id}/`,
+  versions: [
+    {
+      version: pkgVersionForVersions(),
+      generatedAt: new Date().toISOString(),
+      changeSummary: `Build ${new Date().toISOString().slice(0, 10)}`,
+    },
+  ],
+}));
+
+if (datasetVersions.length > 0) {
+  const versionTtl = datasetVersions.map(v =>
+    buildVersionHistoryTurtle({
+      registerId: v.registerId,
+      datasetIri: v.datasetIri,
+      versions: v.versions,
+      associatedAgentIri: process.env.CI_BOT_AGENT_IRI ?? null,
+    }),
+  ).join('\n');
+  fs.writeFileSync(path.join(DATA, 'versions.ttl'), versionTtl);
+  console.log(`Emitted versions graph: data/versions.ttl (${datasetVersions.length} datasets)`);
+}
+
+function pkgVersionForVersions() {
+  return JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')).version;
+}

package/scripts/generate-ontology-data.mjs

@@ -3,7 +3,7 @@
  * Extract SKOS taxonomy data from concept-model TTL files into JSON
  * for browser consumption via the OntologyRegistry.
  *
- * Reads from:  ../concept-model/ontologies/taxonomies/*.ttl
+ * Reads from:  data/concept-model/taxonomies/*.ttl  (vendored from glossarist/concept-model)
  * Writes to:   src/data/taxonomies.json
  */
 
@@ -13,7 +13,7 @@ import { fileURLToPath } from 'url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(__dirname, '..');
-const TAXONOMY_DIR = resolve(ROOT, '..', 'concept-model', 'ontologies', 'taxonomies');
+const TAXONOMY_DIR = resolve(ROOT, 'data', 'concept-model', 'taxonomies');
 const OUTPUT = resolve(ROOT, 'src', 'data', 'taxonomies.json');
 
 /**
@@ -151,7 +151,7 @@ const TAXONOMY_MAP = {
 function main() {
   if (!existsSync(TAXONOMY_DIR)) {
     console.error(`Taxonomy directory not found: ${TAXONOMY_DIR}`);
-    console.error('Ensure concept-model is available at ../concept-model/');
+    console.error('Run `npm run sync:model` to vendor concept-model data.');
     process.exit(1);
   }
 

package/scripts/generate-ontology-schema.mjs

@@ -3,7 +3,7 @@
  * Parse the glossarist OWL ontology (TTL) into a structured JSON schema
  * for the Ontospy-style browser view.
  *
- * Reads:  ../concept-model/ontologies/glossarist.ttl
+ * Reads:  data/concept-model/glossarist.ttl  (vendored from glossarist/concept-model)
  * Writes: src/data/ontology-schema.json
  */
 
@@ -13,7 +13,7 @@ import { fileURLToPath } from 'url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(__dirname, '..');
-const CONCEPT_MODEL = resolve(ROOT, '..', 'concept-model', 'ontologies');
+const CONCEPT_MODEL = resolve(ROOT, 'data', 'concept-model');
 const ONTOLOGY_TTL = resolve(CONCEPT_MODEL, 'glossarist.ttl');
 const SHACL_TTL = resolve(CONCEPT_MODEL, 'shapes', 'glossarist.shacl.ttl');
 const OUTPUT = resolve(ROOT, 'src', 'data', 'ontology-schema.json');
@@ -537,7 +537,7 @@ function parseAnnotationProperties(ttlText) {
 function main() {
   if (!existsSync(ONTOLOGY_TTL)) {
     console.error(`Ontology file not found: ${ONTOLOGY_TTL}`);
-    console.error('Ensure concept-model is available at ../concept-model/');
+    console.error('Run `npm run sync:model` to vendor from glossarist/concept-model.');
     process.exit(1);
   }
 

package/scripts/lib/agents-turtle.mjs

@@ -0,0 +1,64 @@
+function slugify(input) {
+  return String(input)
+    .toLowerCase()
+    .normalize('NFKD')
+    .replace(/[̀-ͯ]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function ttlLit(s) {
+  if (s == null) return '""';
+  const escaped = String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+
+function ttlPrefixed(qname) {
+  const colonIdx = qname.indexOf(':');
+  if (colonIdx < 0) return qname;
+  const local = qname.slice(colonIdx + 1);
+  const escaped = local.replace(/([/])/g, '\\$1');
+  return `${qname.slice(0, colonIdx + 1)}${escaped}`;
+}
+
+export function buildAgentsTurtle(contributors, agentBase = 'https://glossarist.org/agent') {
+  const lines = [];
+  lines.push('@prefix foaf: <http://xmlns.com/foaf/0.1/> .');
+  lines.push('@prefix prov: <http://www.w3.org/ns/prov#> .');
+  lines.push('@prefix dcterms: <http://purl.org/dc/terms/> .');
+  lines.push('@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .');
+  lines.push('');
+
+  const orgSlugs = new Set();
+  for (const c of contributors ?? []) {
+    const slug = slugify(c.name);
+    const iri = `${agentBase}/${slug}`;
+    const personLines = [
+      `<${iri}> a foaf:Person, prov:Person, prov:Agent ;`,
+      `  foaf:name ${ttlLit(c.name)} ;`,
+    ];
+    if (c.email) personLines.push(`  foaf:mbox <mailto:${c.email}> ;`);
+    if (c.url) personLines.push(`  rdfs:seeAlso <${c.url}> ;`);
+    if (c.role) personLines.push(`  dcterms:description ${ttlLit(c.role)} ;`);
+    personLines[personLines.length - 1] = personLines[personLines.length - 1].replace(/ ;$/, ' .');
+    lines.push(...personLines);
+
+    if (c.organization) {
+      const orgSlug = slugify(c.organization);
+      const orgIri = `https://glossarist.org/org/${orgSlug}`;
+      lines[lines.length - 1] = lines[lines.length - 1].replace(/\.$/, ` ;\n  prov:actedOnBehalfOf <${orgIri}> .`);
+
+      if (!orgSlugs.has(orgSlug)) {
+        orgSlugs.add(orgSlug);
+        const orgLines = [
+          ``,
+          `<${orgIri}> a foaf:Organization, prov:Organization, prov:Agent ;`,
+          `  foaf:name ${ttlLit(c.organization)} .`,
+        ];
+        lines.push(...orgLines);
+      }
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}

package/scripts/lib/bibliography-turtle.mjs

@@ -0,0 +1,54 @@
+import { ttlLit, ttlIri } from './turtle-escape.mjs';
+
+function entryFromV3(e, fallbackId) {
+  return {
+    id: e.id ?? fallbackId ?? '',
+    reference: e.reference ?? '',
+    title: e.title,
+    link: e.link,
+    type: e.type,
+  };
+}
+
+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;
+}
+
+export function buildBibliographyTurtle(register, bibliographyJson, baseUri = 'https://glossarist.org') {
+  const lines = [
+    '@prefix dcterms: <http://purl.org/dc/terms/> .',
+    '@prefix foaf: <http://xmlns.com/foaf/0.1/> .',
+    '@prefix gloss: <https://www.glossarist.org/ontologies/> .',
+    '',
+  ];
+
+  const datasetIri = `${baseUri}/${register}/`;
+  const entries = normalizeBibliographyData(bibliographyJson);
+
+  for (const entry of entries) {
+    if (!entry.id || !entry.reference) continue;
+    /* Percent-encode the bib id when embedding it in an IRI — many
+       bibliography ids contain spaces or other reserved chars
+       (e.g. "ISO/IEC 17000:2020") which are forbidden in raw IRI form. */
+    const bibIri = `${datasetIri}bib/${encodeURIComponent(entry.id)}`;
+    lines.push(`${ttlIri(bibIri)} a dcterms:BibliographicResource ;`);
+    lines.push(`  dcterms:identifier ${ttlLit(entry.id)} ;`);
+    lines.push(`  dcterms:bibliographicCitation ${ttlLit(entry.reference)} ;`);
+    if (entry.title) lines.push(`  dcterms:title ${ttlLit(entry.title)} ;`);
+    if (entry.link) lines.push(`  foaf:page ${ttlIri(entry.link)} ;`);
+    if (entry.type) lines.push(`  dcterms:type ${ttlIri(`${baseUri}/${register}/bibtype/${entry.type}`)} ;`);
+    lines.push(`  dcterms:isPartOf ${ttlIri(datasetIri)} .`);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}

package/scripts/lib/build-activity-turtle.mjs

@@ -0,0 +1,92 @@
+const PREFIXES = [
+  ['prov',    'http://www.w3.org/ns/prov#'],
+  ['dcterms', 'http://purl.org/dc/terms/'],
+  ['foaf',    'http://xmlns.com/foaf/0.1/'],
+  ['rdf',     'http://www.w3.org/1999/02/22-rdf-syntax-ns#'],
+  ['rdfs',    'http://www.w3.org/2000/01/rdf-schema#'],
+  ['xsd',     'http://www.w3.org/2001/XMLSchema#'],
+  ['gloss',   'https://www.glossarist.org/ontologies/'],
+];
+
+function ttlLit(s) {
+  if (s == null) return '""';
+  const escaped = String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+
+export function buildActivityTurtle(input) {
+  const lines = [];
+  for (const [prefix, iri] of PREFIXES) {
+    lines.push(`@prefix ${prefix}: <${iri}> .`);
+  }
+  lines.push('');
+
+  const activityIri = `https://glossarist.org/activity/build/${input.runId}`;
+  const usedEntities = [];
+
+  if (input.gitSha) {
+    usedEntities.push({
+      iri: `https://glossarist.org/commit/${input.gitSha}`,
+      types: ['prov:Entity'],
+      label: input.gitSha,
+      extras: input.gitBranch ? [`dcterms:description ${ttlLit(`branch: ${input.gitBranch}`)}`] : [],
+    });
+  }
+
+  usedEntities.push({
+    iri: `https://glossarist.org/tool/${input.toolId}/${input.toolVersion}`,
+    types: ['prov:Entity', 'prov:SoftwareAgent'],
+    label: `${input.toolId} ${input.toolVersion}`,
+    extras: [
+      `dcterms:identifier ${ttlLit(input.toolVersion)}`,
+      `prov:version ${ttlLit(input.toolVersion)}`,
+    ],
+  });
+
+  for (const register of input.datasetRegisters ?? []) {
+    usedEntities.push({
+      iri: `https://glossarist.org/${register}/`,
+      types: ['prov:Entity'],
+      label: register,
+      extras: [],
+    });
+  }
+
+  const activityLines = [
+    `<${activityIri}> a prov:Activity ;`,
+    `  rdfs:label ${ttlLit(`build ${input.runId}`)} ;`,
+    `  prov:generatedAtTime "${input.endedAt}"^^xsd:dateTime ;`,
+  ];
+  for (const ent of usedEntities) {
+    activityLines.push(`  prov:used <${ent.iri}> ;`);
+  }
+  activityLines.push(`  gloss:conceptCount "${input.conceptCount}"^^xsd:integer ;`);
+  if (input.associatedAgentIri) {
+    activityLines.push(`  prov:wasAssociatedWith <${input.associatedAgentIri}> ;`);
+  }
+  activityLines[activityLines.length - 1] = activityLines[activityLines.length - 1].replace(/ ;$/, ' .');
+  lines.push(...activityLines);
+  lines.push('');
+
+  for (const ent of usedEntities) {
+    const entLines = [
+      `<${ent.iri}> a ${ent.types.join(', ')} ;`,
+      `  rdfs:label ${ttlLit(ent.label)}${ent.extras.length > 0 ? ' ;' : ' .'}`,
+    ];
+    for (let i = 0; i < ent.extras.length; i++) {
+      const last = i === ent.extras.length - 1;
+      entLines.push(`  ${ent.extras[i]}${last ? ' .' : ' ;'}`);
+    }
+    lines.push(...entLines);
+    lines.push('');
+  }
+
+  if (input.associatedAgentIri) {
+    const label = input.associatedAgentIri.split('/').pop() ?? 'agent';
+    lines.push(`<${input.associatedAgentIri}> a prov:Agent, foaf:Person ;`);
+    lines.push(`  rdfs:label ${ttlLit(label)} .`);
+    lines.push('');
+  }
+
+  return lines.join('\n') + '\n';
+}

package/scripts/lib/build-cache.mjs

@@ -0,0 +1,70 @@
+// @ts-check
+import { createHash } from 'node:crypto';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+/**
+ * @typedef {Object} BuildCacheEntry
+ * @property {string} hash
+ * @property {unknown} value
+ * @property {string} storedAt
+ */
+
+export class BuildCache {
+  /** @param {string} cacheDir */
+  constructor(cacheDir) {
+    this.cacheDir = cacheDir;
+  }
+
+  /** @template T @param {string} key @returns {Promise<BuildCacheEntry<T> | null>} */
+  async get(key) {
+    const path = this.pathFor(key);
+    try {
+      const text = await readFile(path, 'utf8');
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * @template T
+   * @param {string} key
+   * @param {T} value
+   * @param {string} hash
+   */
+  async set(key, value, hash) {
+    const path = this.pathFor(key);
+    await mkdir(dirname(path), { recursive: true });
+    const entry = { hash, value, storedAt: new Date().toISOString() };
+    await writeFile(path, JSON.stringify(entry));
+  }
+
+  /**
+   * @template T
+   * @param {string} key
+   * @param {string} hash
+   * @param {() => Promise<T>} producer
+   * @returns {Promise<{ value: T; hit: boolean }>}
+   */
+  async readThrough(key, hash, producer) {
+    const cached = await this.get(key);
+    if (cached && cached.hash === hash) {
+      return { value: cached.value, hit: true };
+    }
+    const value = await producer();
+    await this.set(key, value, hash);
+    return { value, hit: false };
+  }
+
+  /** @param {string} key @returns {string} */
+  pathFor(key) {
+    const safe = key.replace(/[^a-zA-Z0-9._-]/g, '_');
+    return `${this.cacheDir}/${safe}.json`;
+  }
+
+  /** @param {string} input @returns {string} */
+  static hash(input) {
+    return createHash('sha256').update(input).digest('hex').slice(0, 16);
+  }
+}

package/scripts/lib/dataset-turtle.mjs

@@ -0,0 +1,79 @@
+const PREFIXES = [
+  ['dcat',     'http://www.w3.org/ns/dcat#'],
+  ['skos',     'http://www.w3.org/2004/02/skos/core#'],
+  ['dcterms',  'http://purl.org/dc/terms/'],
+  ['rdf',      'http://www.w3.org/1999/02/22-rdf-syntax-ns#'],
+  ['rdfs',     'http://www.w3.org/2000/01/rdf-schema#'],
+  ['prov',     'http://www.w3.org/ns/prov#'],
+  ['xsd',      'http://www.w3.org/2001/XMLSchema#'],
+];
+
+function ttlLit(s) {
+  if (s == null) return '""';
+  const escaped = String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+
+export function buildDatasetTurtle(input) {
+  const lines = [];
+  for (const [prefix, iri] of PREFIXES) {
+    lines.push(`@prefix ${prefix}: <${iri}> .`);
+  }
+  lines.push('');
+
+  lines.push(`<${input.datasetIri}> a dcat:Dataset, skos:ConceptScheme ;`);
+  lines.push(`  dcterms:title ${ttlLit(input.title)} ;`);
+  if (input.description) {
+    lines.push(`  dcterms:description ${ttlLit(input.description)} ;`);
+  }
+  lines.push(`  dcterms:modified "${input.modified}"^^xsd:date ;`);
+  lines.push(`  dcterms:identifier ${ttlLit(input.registerId)} ;`);
+
+  for (const lang of input.languages ?? []) {
+    lines.push(`  dcterms:language <http://id.loc.gov/vocabulary/iso639-1/${lang}> ;`);
+  }
+
+  for (const dist of input.distributions ?? []) {
+    lines.push('  dcat:distribution [');
+    lines.push(`    a dcat:Distribution ;`);
+    lines.push(`    dcterms:title ${ttlLit(dist.title)} ;`);
+    lines.push(`    dcat:mediaType ${ttlLit(dist.mediaType)} ;`);
+    lines.push(`    dcat:downloadURL <${dist.downloadUrl}> ;`);
+    if (dist.byteSize != null) {
+      lines.push(`    dcat:byteSize "${dist.byteSize}"^^xsd:integer ;`);
+    }
+    lines.push('  ] ;');
+  }
+
+  for (const concept of input.topConceptUris ?? []) {
+    lines.push(`  skos:hasTopConcept <${concept}> ;`);
+  }
+
+  if (input.sourceRepoUrl) {
+    lines.push(`  prov:wasDerivedFrom <${input.sourceRepoUrl}> ;`);
+  }
+  if (input.publisherIri) {
+    lines.push(`  dcterms:publisher <${input.publisherIri}> ;`);
+  }
+  if (input.contactIri) {
+    lines.push(`  dcat:contactPoint <${input.contactIri}> ;`);
+  }
+
+  lines[lines.length - 1] = lines[lines.length - 1].replace(/ ;$/, ' .');
+
+  for (const section of input.sections ?? []) {
+    lines.push('');
+    lines.push(`<${section.collectionIri}> a skos:Collection ;`);
+    lines.push(`  dcterms:title ${ttlLit(section.title)} ;`);
+    for (const member of section.memberUris) {
+      lines.push(`  skos:member <${member}> ;`);
+    }
+    if (section.memberUris.length === 0) {
+      lines[lines.length - 1] = lines[lines.length - 1].replace(/ ;$/, ' .');
+    } else {
+      lines[lines.length - 1] = lines[lines.length - 1].replace(/ ;$/, ' .');
+    }
+  }
+
+  return lines.join('\n') + '\n';
+}

package/scripts/lib/version-turtle.mjs

@@ -0,0 +1,56 @@
+const PREFIXES = [
+  ['prov',    'http://www.w3.org/ns/prov#'],
+  ['dcterms', 'http://purl.org/dc/terms/'],
+  ['rdfs',    'http://www.w3.org/2000/01/rdf-schema#'],
+  ['xsd',     'http://www.w3.org/2001/XMLSchema#'],
+];
+
+function ttlLit(s) {
+  if (s == null) return '""';
+  const escaped = String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+
+export function buildVersionTurtle(input) {
+  const lines = [];
+  for (const [prefix, iri] of PREFIXES) {
+    lines.push(`@prefix ${prefix}: <${iri}> .`);
+  }
+  lines.push('');
+
+  lines.push(`<${input.versionIri}> a prov:Entity ;`);
+  lines.push(`  rdfs:label ${ttlLit(`${input.registerId} version ${input.version}`)} ;`);
+  lines.push(`  dcterms:isVersionOf <${input.datasetIri}> ;`);
+  if (input.previousVersionIri) {
+    lines.push(`  prov:wasRevisionOf <${input.previousVersionIri}> ;`);
+  }
+  lines.push(`  prov:generatedAtTime "${input.generatedAt}"^^xsd:dateTime ;`);
+  if (input.changeSummary) {
+    lines.push(`  dcterms:description ${ttlLit(input.changeSummary)} ;`);
+  }
+  if (input.associatedAgentIri) {
+    lines.push(`  prov:wasAssociatedWith <${input.associatedAgentIri}> ;`);
+  }
+  lines[lines.length - 1] = lines[lines.length - 1].replace(/ ;$/, ' .');
+  return lines.join('\n') + '\n';
+}
+
+export function buildVersionHistoryTurtle(input) {
+  let previousIri;
+  const blocks = [];
+  for (const v of input.versions ?? []) {
+    const versionIri = `${input.datasetIri}versions/${v.version}`;
+    blocks.push(buildVersionTurtle({
+      registerId: input.registerId,
+      version: v.version,
+      versionIri,
+      datasetIri: input.datasetIri,
+      generatedAt: v.generatedAt,
+      previousVersionIri: previousIri,
+      changeSummary: v.changeSummary,
+      associatedAgentIri: input.associatedAgentIri,
+    }));
+    previousIri = versionIri;
+  }
+  return blocks.join('\n');
+}