@glossarist/concept-browser 0.7.50 → 0.7.52

package/src/components/concept-rdf/jsonld-writer.ts

@@ -0,0 +1,82 @@
+import { RDF_PREFIXES } from './rdf-prefixes';
+import { RDF } from './predicates';
+import type { RdfGraph, RdfResource, RdfTerm, RdfTriple } from './rdf-graph';
+
+export function writeJsonLd(graph: RdfGraph): string {
+  const context: Record<string, string> = {};
+  for (const p of RDF_PREFIXES) {
+    context[p.prefix] = p.iri;
+  }
+
+  const nodes: JsonLdNode[] = [];
+  for (const r of graph.resources()) {
+    nodes.push(resourceToNode(r));
+  }
+
+  const doc = {
+    '@context': context,
+    '@graph': nodes,
+  };
+
+  return JSON.stringify(doc, null, 2);
+}
+
+interface JsonLdNode {
+  [key: string]: unknown;
+}
+
+function resourceToNode(r: RdfResource): JsonLdNode {
+  const node: JsonLdNode = {
+    '@id': r.subject,
+    '@type': [...r.types],
+  };
+  mergeTriplesInto(node, r.triples);
+  return node;
+}
+
+function blankNodeToNode(triples: readonly RdfTriple[]): JsonLdNode {
+  const node: JsonLdNode = {};
+  mergeTriplesInto(node, triples);
+  return node;
+}
+
+function mergeTriplesInto(node: JsonLdNode, triples: readonly RdfTriple[]): void {
+  const grouped = new Map<string, RdfTerm[]>();
+  for (const t of triples) {
+    const arr = grouped.get(t.predicate) ?? [];
+    arr.push(t.object);
+    grouped.set(t.predicate, arr);
+  }
+
+  const typeTerms = grouped.get(RDF.type);
+  if (typeTerms && typeTerms.length > 0) {
+    const typeIris = typeTerms
+      .filter((t): t is Extract<RdfTerm, { kind: 'iri' }> => t.kind === 'iri')
+      .map(t => t.value);
+    if (typeIris.length === 1) {
+      node['@type'] = typeIris[0];
+    } else if (typeIris.length > 1) {
+      node['@type'] = typeIris;
+    }
+    grouped.delete(RDF.type);
+  }
+
+  for (const [pred, terms] of grouped) {
+    node[pred] = terms.length === 1
+      ? termToJson(terms[0])
+      : terms.map(termToJson);
+  }
+}
+
+function termToJson(term: RdfTerm): unknown {
+  switch (term.kind) {
+    case 'iri':
+      return { '@id': term.value };
+    case 'literal':
+      if (term.lang) return { '@value': term.value, '@language': term.lang };
+      if (term.datatype) return { '@value': term.value, '@type': term.datatype };
+      return term.value;
+    case 'blank':
+      return blankNodeToNode(term.triples);
+  }
+}

package/src/components/concept-rdf/predicates.ts

@@ -0,0 +1,261 @@
+export const GLOSS = {
+  // Classes
+  Concept: 'gloss:Concept',
+  LocalizedConcept: 'gloss:LocalizedConcept',
+  Designation: 'gloss:Designation',
+  Expression: 'gloss:Expression',
+  Abbreviation: 'gloss:Abbreviation',
+  Symbol: 'gloss:Symbol',
+  LetterSymbol: 'gloss:LetterSymbol',
+  GraphicalSymbol: 'gloss:GraphicalSymbol',
+
+  DetailedDefinition: 'gloss:DetailedDefinition',
+  ConceptDate: 'gloss:ConceptDate',
+  ConceptSource: 'gloss:ConceptSource',
+  ConceptRef: 'gloss:ConceptRef',
+  NonVerbalEntity: 'gloss:NonVerbalEntity',
+  NonVerbalRep: 'gloss:NonVerbalRep',
+  NonVerbalRepresentation: 'gloss:NonVerbalRepresentation',
+  Figure: 'gloss:Figure',
+  Table: 'gloss:Table',
+  Formula: 'gloss:Formula',
+  RelatedConcept: 'gloss:RelatedConcept',
+  Citation: 'gloss:Citation',
+  CitationRef: 'gloss:CitationRef',
+  Locality: 'gloss:Locality',
+  CustomLocality: 'gloss:CustomLocality',
+  Reference: 'gloss:Reference',
+  ConceptCollection: 'gloss:ConceptCollection',
+
+  // Concept predicates
+  identifier: 'gloss:identifier',
+  uri: 'gloss:uri',
+  hasStatus: 'gloss:hasStatus',
+  hasEntryStatus: 'gloss:hasEntryStatus',
+  hasLocalization: 'gloss:hasLocalization',
+  isLocalizationOf: 'gloss:isLocalizationOf',
+  hasDomain: 'gloss:hasDomain',
+  domain: 'gloss:domain',
+  hasSource: 'gloss:hasSource',
+  hasDate: 'gloss:hasDate',
+  hasRelatedConcept: 'gloss:hasRelatedConcept',
+  hasDesignation: 'gloss:hasDesignation',
+  hasDefinition: 'gloss:hasDefinition',
+  hasNote: 'gloss:hasNote',
+  hasExample: 'gloss:hasExample',
+  hasAnnotation: 'gloss:hasAnnotation',
+  hasNonVerbalRep: 'gloss:hasNonVerbalRep',
+  hasReference: 'gloss:hasReference',
+  hasPronunciation: 'gloss:hasPronunciation',
+  hasGrammarInfo: 'gloss:hasGrammarInfo',
+  hasTermType: 'gloss:hasTermType',
+  tag: 'gloss:tag',
+  register: 'gloss:register',
+
+  // Lifecycle / review
+  reviewDate: 'gloss:reviewDate',
+  reviewDecisionDate: 'gloss:reviewDecisionDate',
+  reviewDecisionEvent: 'gloss:reviewDecisionEvent',
+  reviewStatus: 'gloss:reviewStatus',
+  reviewDecision: 'gloss:reviewDecision',
+  reviewDecisionNotes: 'gloss:reviewDecisionNotes',
+  reviewType: 'gloss:reviewType',
+  lineageSourceSimilarity: 'gloss:lineageSimilarity',
+  lineageSimilarity: 'gloss:lineageSimilarity',
+  release: 'gloss:release',
+  classification: 'gloss:classification',
+  script: 'gloss:script',
+  system: 'gloss:conversionSystem',
+  conversionSystem: 'gloss:conversionSystem',
+  language: 'gloss:language',
+
+  // Non-verbal
+  nonVerbalType: 'gloss:representationType',
+  representationType: 'gloss:representationType',
+  representationRef: 'gloss:representationRef',
+  hasNonVerbalRepresentation: 'gloss:hasNonVerbalRepresentation',
+  expression: 'gloss:expression',
+  latexForm: 'gloss:latexForm',
+  content: 'gloss:content',
+  hasHeader: 'gloss:hasHeader',
+  hasRow: 'gloss:hasRow',
+  image: 'gloss:image',
+  caption: 'gloss:caption',
+  altText: 'gloss:altText',
+
+  // Designation
+  normativeStatus: 'gloss:normativeStatus',
+  geographicalArea: 'gloss:geographicalArea',
+  fieldOfApplication: 'gloss:fieldOfApplication',
+  prefix: 'gloss:prefix',
+  usageInfo: 'gloss:usageInfo',
+  text: 'gloss:text',
+  isInternational: 'gloss:isInternational',
+  isAbsent: 'gloss:isAbsent',
+  isAcronym: 'gloss:isAcronym',
+  isInitialism: 'gloss:isInitialism',
+  isTruncation: 'gloss:isTruncation',
+
+  // Related concept / ConceptRef
+  relationshipType: 'gloss:relationshipType',
+  relationshipContent: 'gloss:relationshipContent',
+  relationshipRef: 'gloss:relationshipRef',
+  conceptRefSource: 'gloss:conceptRefSource',
+  conceptRefId: 'gloss:conceptRefId',
+
+  // ConceptDate
+  dateType: 'gloss:dateType',
+  dateValue: 'gloss:dateValue',
+  eventDescription: 'gloss:eventDescription',
+
+  // ConceptSource
+  sourceStatus: 'gloss:sourceStatus',
+  sourceType: 'gloss:sourceType',
+  sourceOrigin: 'gloss:sourceOrigin',
+  modification: 'gloss:modification',
+
+  // Citation
+  hasCitationRef: 'gloss:hasCitationRef',
+  hasCitationLocality: 'gloss:hasCitationLocality',
+  citationLink: 'gloss:citationLink',
+  citationOriginal: 'gloss:citationOriginal',
+  hasCustomLocality: 'gloss:hasCustomLocality',
+  bibliographicCitation: 'gloss:bibliographicCitation',
+
+  // CitationRef
+  citationRefSource: 'gloss:citationRefSource',
+  citationRefId: 'gloss:citationRefId',
+  citationRefVersion: 'gloss:citationRefVersion',
+
+  // Reference
+  refSource: 'gloss:source',
+  refId: 'gloss:refId',
+  refVersion: 'gloss:refVersion',
+  refLink: 'gloss:refLink',
+  refType: 'gloss:refType',
+  urn: 'gloss:urn',
+  term: 'gloss:term',
+  hasLocality: 'gloss:hasLocality',
+
+  // Locality
+  localityType: 'gloss:localityType',
+  referenceFrom: 'gloss:referenceFrom',
+  referenceTo: 'gloss:referenceTo',
+  customLocalityName: 'gloss:customLocalityName',
+  customLocalityValue: 'gloss:customLocalityValue',
+} as const;
+
+export const SKOS = {
+  Concept: 'skos:Concept',
+  Collection: 'skos:Collection',
+  ConceptScheme: 'skos:ConceptScheme',
+  prefLabel: 'skos:prefLabel',
+  altLabel: 'skos:altLabel',
+  definition: 'skos:definition',
+  scopeNote: 'skos:scopeNote',
+  notation: 'skos:notation',
+  member: 'skos:member',
+  hasTopConcept: 'skos:hasTopConcept',
+  inScheme: 'skos:inScheme',
+} as const;
+
+export const SKOSXL = {
+  Label: 'skosxl:Label',
+  prefLabel: 'skosxl:prefLabel',
+  altLabel: 'skosxl:altLabel',
+  literalForm: 'skosxl:literalForm',
+} as const;
+
+export const DCTERMS = {
+  language: 'dcterms:language',
+  source: 'dcterms:source',
+  title: 'dcterms:title',
+  description: 'dcterms:description',
+  created: 'dcterms:created',
+  modified: 'dcterms:modified',
+  identifier: 'dcterms:identifier',
+  date: 'dcterms:date',
+  type: 'dcterms:type',
+  isVersionOf: 'dcterms:isVersionOf',
+  isPartOf: 'dcterms:isPartOf',
+  replaces: 'dcterms:replaces',
+  isReplacedBy: 'dcterms:isReplacedBy',
+  bibliographicCitation: 'dcterms:bibliographicCitation',
+  subject: 'dcterms:subject',
+  format: 'dcterms:format',
+  publisher: 'dcterms:publisher',
+  contactPoint: 'dcterms:contactPoint',
+  BibliographicResource: 'dcterms:BibliographicResource',
+} as const;
+
+export const RDF = {
+  type: 'rdf:type',
+  value: 'rdf:value',
+} as const;
+
+export const OWL = {
+  Thing: 'owl:Thing',
+  sameAs: 'owl:sameAs',
+  deprecated: 'owl:deprecated',
+} as const;
+
+export const RDFS = {
+  seeAlso: 'rdfs:seeAlso',
+  label: 'rdfs:label',
+  comment: 'rdfs:comment',
+} as const;
+
+export const PROV = {
+  wasGeneratedBy: 'prov:wasGeneratedBy',
+  generatedAtTime: 'prov:generatedAtTime',
+  wasDerivedFrom: 'prov:wasDerivedFrom',
+  wasAttributedTo: 'prov:wasAttributedTo',
+  invalidatedAtTime: 'prov:invalidatedAtTime',
+  wasInvalidatedBy: 'prov:wasInvalidatedBy',
+  wasAssociatedWith: 'prov:wasAssociatedWith',
+  wasRevisionOf: 'prov:wasRevisionOf',
+  used: 'prov:used',
+  actedOnBehalfOf: 'prov:actedOnBehalfOf',
+  Activity: 'prov:Activity',
+  Entity: 'prov:Entity',
+  Agent: 'prov:Agent',
+  Organization: 'prov:Organization',
+  Person: 'prov:Person',
+} as const;
+
+export const DCAT = {
+  Dataset: 'dcat:Dataset',
+  DatasetSeries: 'dcat:DatasetSeries',
+  Catalog: 'dcat:Catalog',
+  Distribution: 'dcat:Distribution',
+  distribution: 'dcat:distribution',
+  dataset: 'dcat:dataset',
+  hasVersion: 'dcat:hasVersion',
+  isVersionOf: 'dcat:isVersionOf',
+  hasCurrentVersion: 'gloss:hasCurrentVersion',
+  isCurrentVersionOf: 'gloss:isCurrentVersionOf',
+  downloadURL: 'dcat:downloadURL',
+  mediaType: 'dcat:mediaType',
+  byteSize: 'dcat:byteSize',
+  contactPoint: 'dcat:contactPoint',
+  theme: 'dcat:theme',
+  keyword: 'dcat:keyword',
+} as const;
+
+export const FOAF = {
+  Person: 'foaf:Person',
+  Organization: 'foaf:Organization',
+  name: 'foaf:name',
+  mbox: 'foaf:mbox',
+  page: 'foaf:page',
+  Image: 'foaf:Image',
+} as const;
+
+export const XSD = {
+  dateTime: 'xsd:dateTime',
+  date: 'xsd:date',
+  boolean: 'xsd:boolean',
+  integer: 'xsd:integer',
+  string: 'xsd:string',
+  anyURI: 'xsd:anyURI',
+} as const;

package/src/components/concept-rdf/provenance.ts

@@ -0,0 +1,80 @@
+import type { RdfGraph } from './rdf-graph';
+import { PROV, DCTERMS, XSD } from './predicates';
+
+/**
+ * Provenance information attached to every emitted concept graph.
+ *
+ * The `toolId` and `toolVersion` identify the serializer that produced
+ * the document; together they form the PROV-O activity IRI
+ * (`<activity/serializers/{toolId}/{version}>`). The `generatedAt`
+ * timestamp is when this document came into existence — at build
+ * time for static dumps, at view time for client-side emission.
+ *
+ * `canonicalUri` is the unversioned concept URI; `dcterms:isVersionOf`
+ * points there from the versioned concept resource.
+ */
+export interface ProvenanceOptions {
+  readonly toolId: string;
+  readonly toolVersion: string;
+  readonly generatedAt: string;
+  readonly canonicalUri?: string;
+}
+
+export const SERIALIZER_TOOL_ID = 'concept-browser';
+
+/**
+ * Compose the PROV-O activity IRI for a given tool + version. Format:
+ * `activity/serializers/{toolId}/{version}`. This is a relative IRI;
+ * under the document base it resolves to a per-tool activity resource.
+ */
+export function activityUri(opts: ProvenanceOptions): string {
+  return `activity/serializers/${opts.toolId}/${opts.toolVersion}`;
+}
+
+/**
+ * Attach provenance triples to the concept resource identified by
+ * `subjectUri` in `graph`. Idempotent — calling twice with the same
+ * arguments produces the same single set of triples (the underlying
+ * RdfGraph deduplicates).
+ *
+ * The decorator is invoked AFTER the base emitter has populated the
+ * graph, keeping domain emission (concept-emitter.ts) decoupled from
+ * build/render context (timestamp, tool version). See ADR 0001 for
+ * the rationale.
+ */
+export function decorateWithProvenance(
+  graph: RdfGraph,
+  subjectUri: string,
+  opts: ProvenanceOptions,
+): void {
+  const w = graph.declare(subjectUri, {});
+  w.iri(PROV.wasGeneratedBy, activityUri(opts));
+  w.literal(PROV.generatedAtTime, opts.generatedAt, { datatype: XSD.dateTime });
+  if (opts.canonicalUri && opts.canonicalUri !== subjectUri) {
+    w.iri(DCTERMS.isVersionOf, opts.canonicalUri);
+  }
+
+  graph.declare(activityUri(opts), {
+    types: [PROV.Activity],
+    label: `${opts.toolId} ${opts.toolVersion}`,
+  });
+}
+
+/**
+ * Build ProvenanceOptions for runtime emission in the browser. Uses
+ * the current wall-clock time as `generatedAt`. Callers that want a
+ * deterministic timestamp (e.g., build scripts, snapshot tests)
+ * should construct the options directly.
+ */
+export function runtimeProvenance(
+  toolVersion: string,
+  canonicalUri?: string,
+  now: () => Date = () => new Date(),
+): ProvenanceOptions {
+  return {
+    toolId: SERIALIZER_TOOL_ID,
+    toolVersion,
+    generatedAt: now().toISOString(),
+    canonicalUri,
+  };
+}

package/src/components/concept-rdf/rdf-graph.ts

@@ -0,0 +1,211 @@
+/**
+ * RDF intermediate representation — a subject-grouped triple graph.
+ *
+ * The graph is the single source of truth for all RDF emission. The
+ * ConceptEmitter walks the Concept model and populates an RdfGraph; the
+ * Turtle/JSON-LD writers and the UI sections builder all consume the
+ * same graph. Adding a new field touches exactly one site (the emitter),
+ * not three.
+ *
+ * Terms use prefixed names (`gloss:Concept`) or absolute IRIs
+ * (`https://glossarist.org/...`). Writers decide how to render each.
+ */
+
+export type RdfTerm = RdfIri | RdfLiteral | RdfBlankNode;
+
+export interface RdfIri {
+  readonly kind: 'iri';
+  readonly value: string;
+}
+
+export interface RdfLiteral {
+  readonly kind: 'literal';
+  readonly value: string;
+  readonly lang?: string;
+  readonly datatype?: string;
+}
+
+export interface RdfBlankNode {
+  readonly kind: 'blank';
+  readonly triples: RdfTriple[];
+}
+
+export interface RdfTriple {
+  readonly predicate: string;
+  readonly object: RdfTerm;
+}
+
+export interface RdfResource {
+  readonly subject: string;
+  readonly types: readonly string[];
+  readonly triples: readonly RdfTriple[];
+  readonly label: string;
+  readonly classLabel: string;
+  readonly classId: string;
+}
+
+interface MutableResource {
+  readonly subject: string;
+  readonly types: string[];
+  readonly triples: RdfTriple[];
+  label: string;
+  classLabel: string;
+  classId: string;
+}
+
+export interface ResourceInit {
+  readonly types?: readonly string[];
+  readonly label?: string;
+  readonly classLabel?: string;
+  readonly classId?: string;
+}
+
+export function lit(value: string, opts: { lang?: string; datatype?: string } = {}): RdfLiteral {
+  return { kind: 'literal', value, lang: opts.lang, datatype: opts.datatype };
+}
+
+export function iri(value: string): RdfIri {
+  return { kind: 'iri', value };
+}
+
+export function blank(...triples: RdfTriple[]): RdfBlankNode {
+  return { kind: 'blank', triples };
+}
+
+export function triple(predicate: string, object: RdfTerm): RdfTriple {
+  return { predicate, object };
+}
+
+export function termEquals(a: RdfTerm, b: RdfTerm): boolean {
+  if (a.kind !== b.kind) return false;
+  switch (a.kind) {
+    case 'iri':
+      return a.value === (b as RdfIri).value;
+    case 'literal': {
+      const o = b as RdfLiteral;
+      return a.value === o.value && a.lang === o.lang && a.datatype === o.datatype;
+    }
+    case 'blank': {
+      const o = b as RdfBlankNode;
+      if (a.triples.length !== o.triples.length) return false;
+      return a.triples.every((t, i) => {
+        const u = o.triples[i];
+        return t.predicate === u.predicate && termEquals(t.object, u.object);
+      });
+    }
+  }
+}
+
+export class RdfGraph {
+  private readonly _resources = new Map<string, MutableResource>();
+  private readonly _order: string[] = [];
+
+  declare(subject: string, init: ResourceInit = {}): ResourceWriter {
+    let r = this._resources.get(subject);
+    if (!r) {
+      r = {
+        subject,
+        types: [...(init.types ?? [])],
+        triples: [],
+        label: init.label ?? subject,
+        classLabel: init.classLabel ?? '',
+        classId: init.classId ?? '',
+      };
+      this._resources.set(subject, r);
+      this._order.push(subject);
+    } else {
+      if (init.types) {
+        for (const t of init.types) {
+          if (!r.types.includes(t)) r.types.push(t);
+        }
+      }
+      if (init.label !== undefined && r.label === subject) r.label = init.label;
+      if (init.classLabel && !r.classLabel) r.classLabel = init.classLabel;
+      if (init.classId && !r.classId) r.classId = init.classId;
+    }
+    return new ResourceWriter(r.triples);
+  }
+
+  has(subject: string): boolean {
+    return this._resources.has(subject);
+  }
+
+  get(subject: string): RdfResource | undefined {
+    return this._resources.get(subject);
+  }
+
+  get size(): number {
+    return this._order.length;
+  }
+
+  *resources(): Iterable<RdfResource> {
+    for (const s of this._order) {
+      yield this._resources.get(s)!;
+    }
+  }
+
+  toArray(): RdfResource[] {
+    return Array.from(this.resources());
+  }
+
+  merge(other: RdfGraph): this {
+    for (const r of other.resources()) {
+      const w = this.declare(r.subject, {
+        types: [...r.types],
+        label: r.label,
+        classLabel: r.classLabel,
+        classId: r.classId,
+      });
+      for (const t of r.triples) {
+        if (t.object.kind === 'iri') w.iri(t.predicate, t.object.value);
+        else if (t.object.kind === 'literal') {
+          w.literal(t.predicate, t.object.value, { lang: t.object.lang, datatype: t.object.datatype });
+        } else {
+          w.blank(t.predicate, t.object.triples);
+        }
+      }
+    }
+    return this;
+  }
+}
+
+export class ResourceWriter {
+  constructor(private readonly triples: RdfTriple[]) {}
+
+  add(predicate: string, object: RdfTerm): this {
+    if (object.kind === 'literal' && object.value === '') return this;
+    if (object.kind === 'iri' && object.value === '') return this;
+    if (!this.triples.some(t => t.predicate === predicate && termEquals(t.object, object))) {
+      this.triples.push({ predicate, object });
+    }
+    return this;
+  }
+
+  literal(predicate: string, value: string, opts: { lang?: string; datatype?: string } = {}): this {
+    if (!value) return this;
+    return this.add(predicate, { kind: 'literal', value, lang: opts.lang, datatype: opts.datatype });
+  }
+
+  iri(predicate: string, value: string): this {
+    if (!value) return this;
+    return this.add(predicate, { kind: 'iri', value });
+  }
+
+  blank(predicate: string, triples: readonly RdfTriple[]): this {
+    if (triples.length === 0) return this;
+    return this.add(predicate, { kind: 'blank', triples: [...triples] });
+  }
+
+  addTriple(t: RdfTriple): this {
+    return this.add(t.predicate, t.object);
+  }
+
+  addTriples(triples: readonly RdfTriple[]): this {
+    for (const t of triples) this.addTriple(t);
+    return this;
+  }
+}
+
+export function isAbsoluteIri(s: string): boolean {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(s) || s.startsWith('urn:');
+}

package/src/components/concept-rdf/rdf-prefixes.ts

@@ -0,0 +1,23 @@
+export interface PrefixEntry {
+  prefix: string;
+  iri: string;
+  description: string;
+}
+
+export const RDF_PREFIXES: readonly PrefixEntry[] = [
+  { prefix: 'gloss',    iri: 'https://www.glossarist.org/ontologies/',                description: 'Glossarist ontology' },
+  { prefix: 'skos',     iri: 'http://www.w3.org/2004/02/skos/core#',                  description: 'Simple Knowledge Organization System' },
+  { prefix: 'skosxl',   iri: 'http://www.w3.org/2008/05/skos-xl#',                    description: 'SKOS eXtension for Labels' },
+  { prefix: 'rdf',      iri: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',           description: 'RDF core vocabulary' },
+  { prefix: 'rdfs',     iri: 'http://www.w3.org/2000/01/rdf-schema#',                 description: 'RDF Schema' },
+  { prefix: 'owl',      iri: 'http://www.w3.org/2002/07/owl#',                        description: 'Web Ontology Language' },
+  { prefix: 'dcterms',  iri: 'http://purl.org/dc/terms/',                             description: 'Dublin Core terms' },
+  { prefix: 'prov',     iri: 'http://www.w3.org/ns/prov#',                            description: 'PROV-O provenance' },
+  { prefix: 'dcat',     iri: 'http://www.w3.org/ns/dcat#',                            description: 'Data Catalog vocabulary' },
+  { prefix: 'foaf',     iri: 'http://xmlns.com/foaf/0.1/',                            description: 'Friend-of-a-Friend agents' },
+  { prefix: 'xsd',      iri: 'http://www.w3.org/2001/XMLSchema#',                     description: 'XML Schema datatypes' },
+] as const;
+
+export function findPrefix(prefix: string): PrefixEntry | undefined {
+  return RDF_PREFIXES.find(p => p.prefix === prefix);
+}