glossarist 0.4.49 → 0.4.51

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

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

package/src/rdf/gloss-partitive-relation.ts

@@ -1,89 +0,0 @@
-// PartitiveHyperedge → RDF quads.
-//
-// Shape (per concept-model ontology, v3.2.0):
-//
-//   <base>/partitive-relation/<carrying-id>/<comprehensive-id>
-//     rdf:type                       gloss:PartitiveHyperedge
-//     gloss:comprehensive            <base>/concept/<comprehensive-id>      (named node)
-//     gloss:hasPartitive             <base>/concept/<partitive-id>         (named node, one per member)
-//     gloss:completeness             <.../completeness/complete|partial>   (named node, SKOS)
-//     gloss:criterion                "..."@lang                             (literal, one per language)
-//
-// Per-member multiplicity + is_delimiting are emitted by the
-// `partitiveMemberToQuads` helper in `gloss-partitive-member.js`.
-//
-// The carrying concept links via `gloss:hasPartitiveRelation`.
-//
-// Per
-// TODO.partitive-relation-v2 item 01.
-// Cross-repo alignment with glossarist-ruby's Rdf::GlossPartitiveRelation.
-//
-// JSON-LD `@type: @id` invariant: `multiplicity` and `completeness`
-// are URI references into SKOS taxonomies (per
-// `data/concept-model/glossarist.context.jsonld`), not literals.
-// `criterion` is `@container: @language` (one literal per language).
-// `isDelimiting` is `xsd:boolean` literal.
-
-import { PRED } from './predicates.js';
-import { WELL_KNOWN } from './prefixes.js';
-import { partitiveMemberToQuads } from './gloss-partitive-member.js';
-import { namedNode, literal, quad } from './terms.js';
-
-const COMPLETENESS_NS = 'https://www.glossarist.org/ontologies/completeness/';
-
-export function* partitiveRelationToQuads(relation, { parentUri, index }) {
-  const subjectUri = partitiveRelationSubjectUri(parentUri, relation, index);
-  const s = namedNode(subjectUri);
-
-  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.PartitiveHyperedge));
-
-  const comp = relation.comprehensive;
-  if (comp && (comp.source || comp.id)) {
-    yield quad(s, namedNode(PRED.gloss.comprehensive),
-      namedNode(conceptRefUri(comp, parentUri)));
-  }
-
-  const members = Array.isArray(relation.partitives) ? relation.partitives : [];
-  for (const member of members) {
-    const ref = member?.ref ?? member;
-    if (!ref || (!ref.source && !ref.id)) continue;
-    const memberUri = conceptRefUri(ref, parentUri);
-    yield quad(s, namedNode(PRED.gloss.hasPartitive), namedNode(memberUri));
-    yield* partitiveMemberToQuads(member, { memberUri });
-  }
-
-  if (relation.completeness) {
-    yield quad(s, namedNode(PRED.gloss.completeness),
-      namedNode(COMPLETENESS_NS + relation.completeness));
-  }
-
-  if (relation.criterion && typeof relation.criterion === 'object') {
-    for (const [lang, text] of Object.entries(relation.criterion)) {
-      if (typeof text !== 'string') continue;
-      yield quad(s, namedNode(PRED.gloss.criterion), literal(text, lang));
-    }
-  }
-}
-
-// Subject URI scheme: `<base>/partitive-relation/<carrying-id>/<comprehensive-id>`.
-// Matches the Ruby emitter's scheme. Falls back to an index suffix if
-// the comprehensive has no id, so two relations on the same concept
-// never collide.
-export function partitiveRelationSubjectUri(parentUri, relation, index) {
-  const base = parentUri.replace(/\/concept\/[^/]+$/, '');
-  const carrierId = parentUri.split('/concept/')[1] ?? `carrier-${index}`;
-  const compId = relation?.comprehensive?.id ?? `comp-${index}`;
-  return `${base}/partitive-relation/${carrierId}/${compId}`;
-}
-
-// ConceptRef URI resolution: `<base>/concept/<id>` for any ref with an
-// id. Source is dropped (matches Ruby). Falls back to a stable urn:/
-// form for refs with only a source (rare).
-function conceptRefUri(ref, parentUri) {
-  const id = ref?.id;
-  if (id) {
-    const base = parentUri.split('/concept/')[0];
-    return `${base}/concept/${id}`;
-  }
-  return `urn:glossarist:${ref?.source ?? 'unknown'}:`;
-}

package/src/rdf/gloss-source.ts

@@ -1,56 +0,0 @@
-// ConceptSource → RDF quads. Mirrors glossarist-ruby's
-// `Rdf::GlossConceptSource` + `Rdf::GlossCitation`. Sources are reified
-// resources linked from their parent (concept or localized concept or
-// definition) via `gloss:hasSource`.
-import { PRED } from './predicates.js';
-import { WELL_KNOWN } from './prefixes.js';
-import { deterministicBnode } from './deterministic-id.js';
-import { normalizeEnum } from './normalize-enum.js';
-import { namedNode, literal, quad } from './terms.js';
-
-export function* conceptSourceToQuads(source, { subjectUri, index }) {
-  const srcSubject = deterministicBnode(subjectUri, 'source', index);
-
-  yield quad(namedNode(subjectUri), namedNode(PRED.gloss.hasSource), namedNode(srcSubject));
-  yield quad(namedNode(srcSubject), namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.ConceptSource));
-
-  const statusToken = normalizeEnum(source.status);
-  if (statusToken) {
-    yield quad(namedNode(srcSubject), namedNode(PRED.gloss.sourceStatus), namedNode(`${PRED.gloss.$ns}srcstatus/${statusToken}`));
-  }
-  const typeToken = normalizeEnum(source.type);
-  if (typeToken) {
-    yield quad(namedNode(srcSubject), namedNode(PRED.gloss.sourceType), namedNode(`${PRED.gloss.$ns}srctype/${typeToken}`));
-  }
-  if (source.modification) {
-    yield quad(namedNode(srcSubject), namedNode(PRED.gloss.modification), literal(source.modification));
-  }
-
-  if (source.origin) {
-    yield* citationToQuads(source.origin, { subjectUri: srcSubject, predicate: PRED.gloss.sourceOrigin, bnodeKey: 'origin' });
-  }
-
-  const sourcedFrom = source.sourcedFrom ?? source.sourced_from ?? [];
-  for (let i = 0; i < sourcedFrom.length; i++) {
-    yield* citationToQuads(sourcedFrom[i], { subjectUri: srcSubject, predicate: PRED.gloss.sourcedFrom, bnodeKey: 'sourced_from', index: i });
-  }
-}
-
-function* citationToQuads(citation, { subjectUri, predicate, bnodeKey, index = 0 }) {
-  const citSubject = deterministicBnode(subjectUri, bnodeKey, index);
-  yield quad(namedNode(subjectUri), namedNode(predicate), namedNode(citSubject));
-  yield quad(namedNode(citSubject), namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.Citation));
-
-  if (citation.original) {
-    yield quad(namedNode(citSubject), namedNode(PRED.gloss.citationOriginal), literal(citation.original));
-  }
-  if (citation.link) {
-    yield quad(namedNode(citSubject), namedNode(PRED.gloss.citationLink), literal(citation.link));
-  }
-
-  if (citation.ref) {
-    if (citation.ref.source) yield quad(namedNode(citSubject), namedNode(PRED.gloss.citationRefSource), literal(citation.ref.source));
-    if (citation.ref.id) yield quad(namedNode(citSubject), namedNode(PRED.gloss.citationRefId), literal(citation.ref.id));
-    if (citation.ref.version) yield quad(namedNode(citSubject), namedNode(PRED.gloss.citationRefVersion), literal(citation.ref.version));
-  }
-}

package/src/rdf/group-emitter.ts

@@ -1,133 +0,0 @@
-// 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';
-import { PREFIXES } from './prefixes.js';
-import { RDF_TYPE } from './curie.js';
-
-// 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`,
-  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.ts

@@ -1,80 +0,0 @@
-// 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';
-import { PREFIXES } from './prefixes.js';
-import { RDF_TYPE } from './curie.js';
-
-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`,
-};
-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`;
-
-// No hardcoded default base URI. Callers MUST pass baseUri explicitly.
-
-/**
- * @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) {
-  if (!baseUri) throw new Error('imageVariantIri requires baseUri — the deployment canonical URI root.');
-  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) {
-  if (!baseUri) throw new Error('imageVariantToQuads requires baseUri — the deployment canonical URI root.');
-  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));
-}