@glossarist/concept-browser 0.7.51 → 0.7.52

package/src/__tests__/concept-rdf/concept-emitter.test.ts

@@ -0,0 +1,258 @@
+import { describe, it, expect } from 'vitest';
+import { Concept } from 'glossarist';
+import { emitConceptGraph } from '../../components/concept-rdf/concept-emitter';
+import { GLOSS, SKOS, SKOSXL, DCTERMS, RDF, RDFS } from '../../components/concept-rdf/predicates';
+import type { RdfBlankNode, RdfLiteral, RdfIri } from '../../components/concept-rdf/rdf-graph';
+
+function makeConcept(): Concept {
+  return Concept.fromJSON({
+    id: '3.1.1',
+    uri: 'https://glossarist.org/test/concept/3.1.1',
+    status: 'valid',
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [
+          { type: 'expression', designation: 'atomic data unit', normative_status: 'preferred' },
+          { type: 'expression', designation: 'ADU', normative_status: 'admitted' },
+        ],
+        definition: [{ content: 'A data unit that cannot be subdivided.' }],
+        notes: [{ content: 'Note here.' }],
+        examples: [{ content: 'Example here.' }],
+      },
+    },
+  });
+}
+
+describe('emitConceptGraph', () => {
+  it('produces one resource per concept + localized + designation', () => {
+    const { graph } = emitConceptGraph(makeConcept(), 'https://glossarist.org/test/concept/3.1.1');
+    const classIds = Array.from(graph.resources()).map(r => r.classId);
+    expect(classIds).toContain(GLOSS.Concept);
+    expect(classIds).toContain(GLOSS.LocalizedConcept);
+    expect(classIds.filter(c => c === GLOSS.Expression).length).toBe(2);
+  });
+
+  it('declares the concept resource with both gloss:Concept and skos:Concept types', () => {
+    const uri = 'https://glossarist.org/test/concept/3.1.1';
+    const { graph } = emitConceptGraph(makeConcept(), uri);
+    const concept = graph.get(uri)!;
+    expect(concept.types).toContain(GLOSS.Concept);
+    expect(concept.types).toContain(SKOS.Concept);
+  });
+
+  it('emits gloss:hasLocalization as the LAST triple on the concept (UI ordering contract)', () => {
+    const uri = 'https://glossarist.org/test/concept/3.1.1';
+    const { graph } = emitConceptGraph(makeConcept(), uri);
+    const concept = graph.get(uri)!;
+    const last = concept.triples[concept.triples.length - 1];
+    expect(last.predicate).toBe(GLOSS.hasLocalization);
+  });
+
+  it('emits identifiers, status, and localization on the concept', () => {
+    const uri = 'https://glossarist.org/test/concept/3.1.1';
+    const { graph } = emitConceptGraph(makeConcept(), uri);
+    const concept = graph.get(uri)!;
+    const preds = concept.triples.map(t => t.predicate);
+    expect(preds).toContain(GLOSS.identifier);
+    expect(preds).toContain(GLOSS.hasStatus);
+    expect(preds).toContain(GLOSS.hasLocalization);
+  });
+
+  it('emits both skosxl and skos predicates for each designation', () => {
+    const { graph } = emitConceptGraph(makeConcept(), 'https://glossarist.org/test/concept/3.1.1');
+    const lc = graph.get('https://glossarist.org/test/concept/3.1.1/eng')!;
+    const preds = lc.triples.map(t => t.predicate);
+    expect(preds).toContain(SKOSXL.prefLabel);
+    expect(preds).toContain(SKOS.prefLabel);
+    expect(preds).toContain(SKOSXL.altLabel);
+    expect(preds).toContain(SKOS.altLabel);
+  });
+
+  it('emits skos:definition with a language tag', () => {
+    const { graph } = emitConceptGraph(makeConcept(), 'https://glossarist.org/test/concept/3.1.1');
+    const lc = graph.get('https://glossarist.org/test/concept/3.1.1/eng')!;
+    const def = lc.triples.find(t => t.predicate === SKOS.definition);
+    expect(def).toBeDefined();
+    expect((def!.object as any).lang).toBe('eng');
+  });
+
+  it('emits a gloss:hasDefinition blank node reifying the definition', () => {
+    const { graph } = emitConceptGraph(makeConcept(), 'https://glossarist.org/test/concept/3.1.1');
+    const lc = graph.get('https://glossarist.org/test/concept/3.1.1/eng')!;
+    const reified = lc.triples.find(t => t.predicate === GLOSS.hasDefinition);
+    expect(reified).toBeDefined();
+    expect(reified!.object.kind).toBe('blank');
+  });
+
+  it('emits notes and examples as typed gloss:DetailedDefinition blanks with language tag', () => {
+    const { graph } = emitConceptGraph(makeConcept(), 'https://glossarist.org/test/concept/3.1.1');
+    const lc = graph.get('https://glossarist.org/test/concept/3.1.1/eng')!;
+    const note = lc.triples.find(t => t.predicate === GLOSS.hasNote);
+    const example = lc.triples.find(t => t.predicate === GLOSS.hasExample);
+    expect(note).toBeDefined();
+    expect(note!.object.kind).toBe('blank');
+    const noteBlank = note!.object as any;
+    expect(noteBlank.triples.some((t: any) => t.predicate === RDF.type
+      && t.object.kind === 'iri' && t.object.value === GLOSS.DetailedDefinition)).toBe(true);
+    expect(noteBlank.triples.some((t: any) => t.predicate === RDF.value
+      && t.object.lang === 'eng')).toBe(true);
+    expect(example).toBeDefined();
+  });
+
+  it('emits a designation resource per term with the right class', () => {
+    const { graph } = emitConceptGraph(makeConcept(), 'https://glossarist.org/test/concept/3.1.1');
+    const desig1 = graph.get('https://glossarist.org/test/concept/3.1.1/eng/desig/atomic_data_unit');
+    const desig2 = graph.get('https://glossarist.org/test/concept/3.1.1/eng/desig/ADU');
+    expect(desig1).toBeDefined();
+    expect(desig2).toBeDefined();
+    expect(desig1!.classId).toBe(GLOSS.Expression);
+    expect(desig1!.types).toContain(SKOSXL.Label);
+  });
+
+  it('returns the designation URI map keyed by lang#index', () => {
+    const { designationUris } = emitConceptGraph(makeConcept(), 'https://glossarist.org/test/concept/3.1.1');
+    expect(designationUris.get('eng#0')).toBe('https://glossarist.org/test/concept/3.1.1/eng/desig/atomic_data_unit');
+    expect(designationUris.get('eng#1')).toBe('https://glossarist.org/test/concept/3.1.1/eng/desig/ADU');
+  });
+});
+
+describe('emitConceptGraph — structured source/citation (WS K6)', () => {
+  function makeConceptWithSource() {
+    return Concept.fromJSON({
+      id: '3.1.2',
+      uri: 'https://glossarist.org/test/concept/3.1.2',
+      status: 'valid',
+      sources: [
+        {
+          status: 'identical',
+          type: 'authoritative',
+          modification: 'revised 2024',
+          origin: {
+            ref: { source: 'ISO 704', id: '3.1', version: '2020' },
+            locality: { type: 'clause', referenceFrom: '3.1' },
+            link: 'https://example.org/iso-704',
+            original: 'Original wording',
+          },
+        },
+      ],
+      localizations: {
+        eng: {
+          language_code: 'eng',
+          entry_status: 'valid',
+          terms: [{ type: 'expression', designation: 'cited term', normative_status: 'preferred' }],
+          definition: [{ content: 'Definition with citation.' }],
+        },
+      },
+    });
+  }
+
+  function firstSourceBlank(graph: any, uri: string): RdfBlankNode | undefined {
+    const r = graph.get(uri)!;
+    const t = r.triples.find((x: any) => x.predicate === GLOSS.hasSource);
+    return t?.object?.kind === 'blank' ? (t.object as RdfBlankNode) : undefined;
+  }
+
+  it('types every source blank node as gloss:ConceptSource', () => {
+    const uri = 'https://glossarist.org/test/concept/3.1.2';
+    const { graph } = emitConceptGraph(makeConceptWithSource(), uri);
+    const src = firstSourceBlank(graph, uri)!;
+    expect(src).toBeDefined();
+    const typeTriple = src.triples.find(t => t.predicate === RDF.type);
+    expect((typeTriple!.object as RdfIri).value).toBe(GLOSS.ConceptSource);
+  });
+
+  it('emits the formatted bibliographic string on the nested gloss:Citation', () => {
+    const uri = 'https://glossarist.org/test/concept/3.1.2';
+    const { graph } = emitConceptGraph(makeConceptWithSource(), uri);
+    const src = firstSourceBlank(graph, uri)!;
+    const originSlot = src.triples.find(t => t.predicate === GLOSS.sourceOrigin);
+    const cite = (originSlot!.object as RdfBlankNode).triples.find(t => t.predicate === DCTERMS.bibliographicCitation);
+    expect(cite).toBeDefined();
+    expect((cite!.object as RdfLiteral).value).toBe('ISO 704 3.1');
+  });
+
+  it('emits gloss:sourceStatus and gloss:sourceType as IRIs when present', () => {
+    const uri = 'https://glossarist.org/test/concept/3.1.2';
+    const { graph } = emitConceptGraph(makeConceptWithSource(), uri);
+    const src = firstSourceBlank(graph, uri)!;
+    const status = src.triples.find(t => t.predicate === GLOSS.sourceStatus);
+    const type = src.triples.find(t => t.predicate === GLOSS.sourceType);
+    expect((status!.object as RdfIri).value).toBe('gloss:srcstatus/identical');
+    expect((type!.object as RdfIri).value).toBe('gloss:srctype/authoritative');
+  });
+
+  it('emits gloss:modification as a literal on the ConceptSource when modification is present', () => {
+    const uri = 'https://glossarist.org/test/concept/3.1.2';
+    const { graph } = emitConceptGraph(makeConceptWithSource(), uri);
+    const src = firstSourceBlank(graph, uri)!;
+    const mod = src.triples.find(t => t.predicate === GLOSS.modification);
+    expect((mod!.object as RdfLiteral).value).toBe('revised 2024');
+  });
+
+  it('embeds a typed gloss:CitationRef with citationRefSource, citationRefId, citationRefVersion', () => {
+    const uri = 'https://glossarist.org/test/concept/3.1.2';
+    const { graph } = emitConceptGraph(makeConceptWithSource(), uri);
+    const src = firstSourceBlank(graph, uri)!;
+    const originSlot = src.triples.find(t => t.predicate === GLOSS.sourceOrigin)!;
+    const cite = originSlot.object as RdfBlankNode;
+    const refSlot = cite.triples.find(t => t.predicate === GLOSS.hasCitationRef)!;
+    const ref = refSlot.object as RdfBlankNode;
+    expect(ref.triples.find(t => t.predicate === RDF.type)?.object).toMatchObject({ kind: 'iri', value: GLOSS.CitationRef });
+    expect(ref.triples.find(t => t.predicate === GLOSS.citationRefSource)?.object).toMatchObject({ kind: 'literal', value: 'ISO 704' });
+    expect(ref.triples.find(t => t.predicate === GLOSS.citationRefId)?.object).toMatchObject({ kind: 'literal', value: '3.1' });
+    expect(ref.triples.find(t => t.predicate === GLOSS.citationRefVersion)?.object).toMatchObject({ kind: 'literal', value: '2020' });
+  });
+
+  it('embeds a typed gloss:Locality with localityType and referenceFrom', () => {
+    const uri = 'https://glossarist.org/test/concept/3.1.2';
+    const { graph } = emitConceptGraph(makeConceptWithSource(), uri);
+    const src = firstSourceBlank(graph, uri)!;
+    const originSlot = src.triples.find(t => t.predicate === GLOSS.sourceOrigin)!;
+    const cite = originSlot.object as RdfBlankNode;
+    const locSlot = cite.triples.find(t => t.predicate === GLOSS.hasCitationLocality)!;
+    const loc = locSlot.object as RdfBlankNode;
+    expect(loc.triples.find(t => t.predicate === RDF.type)?.object).toMatchObject({ kind: 'iri', value: GLOSS.Locality });
+    expect(loc.triples.find(t => t.predicate === GLOSS.localityType)?.object).toMatchObject({ kind: 'literal', value: 'clause' });
+    expect(loc.triples.find(t => t.predicate === GLOSS.referenceFrom)?.object).toMatchObject({ kind: 'literal', value: '3.1' });
+  });
+
+  it('emits gloss:citationLink and gloss:citationOriginal on the nested Citation', () => {
+    const uri = 'https://glossarist.org/test/concept/3.1.2';
+    const { graph } = emitConceptGraph(makeConceptWithSource(), uri);
+    const src = firstSourceBlank(graph, uri)!;
+    const originSlot = src.triples.find(t => t.predicate === GLOSS.sourceOrigin)!;
+    const cite = originSlot.object as RdfBlankNode;
+    const link = cite.triples.find(t => t.predicate === GLOSS.citationLink);
+    const original = cite.triples.find(t => t.predicate === GLOSS.citationOriginal);
+    expect((link!.object as RdfLiteral).value).toBe('https://example.org/iso-704');
+    expect((link!.object as any).datatype).toBe('xsd:anyURI');
+    expect((original!.object as RdfLiteral).value).toBe('Original wording');
+  });
+
+  it('skips the source block entirely when the origin is empty', () => {
+    const concept = Concept.fromJSON({
+      id: '3.1.3',
+      uri: 'https://glossarist.org/test/concept/3.1.3',
+      status: 'valid',
+      sources: [{ status: null, type: null, origin: null }],
+      localizations: {
+        eng: {
+          language_code: 'eng',
+          terms: [{ type: 'expression', designation: 'x', normative_status: 'preferred' }],
+          definition: [{ content: 'def' }],
+        },
+      },
+    });
+    const uri = 'https://glossarist.org/test/concept/3.1.3';
+    const { graph } = emitConceptGraph(concept, uri);
+    // The type triple is always emitted, so the blank exists — but it has no citation/ref/locality.
+    const r = graph.get(uri)!;
+    const sourceTriples = r.triples.filter(t => t.predicate === GLOSS.hasSource);
+    expect(sourceTriples).toHaveLength(1);
+    const blank = sourceTriples[0].object as RdfBlankNode;
+    expect(blank.triples).toHaveLength(1); // only the type triple
+    expect(blank.triples[0].predicate).toBe(RDF.type);
+  });
+});

package/src/__tests__/concept-rdf/dataset-emitter.test.ts

@@ -0,0 +1,224 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { writeJsonLd } from '../../components/concept-rdf/jsonld-writer';
+import { emitDatasetGraph } from '../../components/concept-rdf/dataset-emitter';
+import type { DatasetEmitterInput } from '../../components/concept-rdf/dataset-emitter';
+
+const DATASET_BASE = 'https://glossarist.org/dataset';
+
+function makeInput(overrides: Partial<DatasetEmitterInput> = {}): DatasetEmitterInput {
+  return {
+    datasetIri: `${DATASET_BASE}/test`,
+    registerId: 'test',
+    title: 'Test Glossary',
+    description: 'A test dataset.',
+    modified: '2026-06-28',
+    languages: ['eng', 'fra'],
+    distributions: [
+      {
+        id: 'test-ttl',
+        title: 'Turtle distribution',
+        mediaType: 'text/turtle',
+        downloadUrl: 'https://glossarist.org/data/test.ttl',
+        byteSize: 12345,
+      },
+      {
+        id: 'test-tbx',
+        title: 'TBX distribution',
+        mediaType: 'application/x-tbx',
+        downloadUrl: 'https://glossarist.org/data/test.tbx.xml',
+      },
+    ],
+    topConceptUris: [
+      `${DATASET_BASE}/test/concept/1`,
+      `${DATASET_BASE}/test/concept/2`,
+    ],
+    sections: [
+      {
+        collectionIri: `${DATASET_BASE}/test/section/3-1`,
+        title: 'Geodetic concepts',
+        memberUris: [`${DATASET_BASE}/test/concept/1`, `${DATASET_BASE}/test/concept/2`],
+      },
+    ],
+    sourceRepoUrl: 'https://github.com/example/test',
+    publisherIri: 'https://glossarist.org/agent/test-publisher',
+    contactIri: 'https://glossarist.org/agent/test-contact',
+    ...overrides,
+  };
+}
+
+function parseTurtle(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+const expand = (v: string): string => {
+  if (v.startsWith('dcat:'))    return `http://www.w3.org/ns/dcat#${v.slice(5)}`;
+  if (v.startsWith('skos:'))    return `http://www.w3.org/2004/02/skos/core#${v.slice(5)}`;
+  if (v.startsWith('dcterms:')) return `http://purl.org/dc/terms/${v.slice(8)}`;
+  if (v.startsWith('rdf:'))     return `http://www.w3.org/1999/02/22-rdf-syntax-ns#${v.slice(4)}`;
+  if (v.startsWith('prov:'))    return `http://www.w3.org/ns/prov#${v.slice(5)}`;
+  if (v.startsWith('xsd:'))     return `http://www.w3.org/2001/XMLSchema#${v.slice(4)}`;
+  return v;
+};
+
+describe('emitDatasetGraph — J2 dcat:Dataset / skos:ConceptScheme', () => {
+  it('types the dataset as dcat:Dataset and skos:ConceptScheme', () => {
+    const input = makeInput();
+    const { graph } = { graph: emitDatasetGraph(input) };
+    const store = parseTurtle(writeTurtle(graph));
+    const types = store.getObjects(input.datasetIri, expand('rdf:type'), null).map(q => q.value);
+    expect(types).toContain(expand('dcat:Dataset'));
+    expect(types).toContain(expand('skos:ConceptScheme'));
+  });
+
+  it('emits title, description, modified, and identifier', () => {
+    const input = makeInput();
+    const graph = emitDatasetGraph(input);
+    const store = parseTurtle(writeTurtle(graph));
+    const titles = store.getObjects(input.datasetIri, expand('dcterms:title'), null).map(q => q.value);
+    expect(titles).toContain('Test Glossary');
+    const descriptions = store.getObjects(input.datasetIri, expand('dcterms:description'), null).map(q => q.value);
+    expect(descriptions).toContain('A test dataset.');
+    const modified = store.getObjects(input.datasetIri, expand('dcterms:modified'), null).map(q => q.value);
+    expect(modified).toContain('2026-06-28');
+    const ids = store.getObjects(input.datasetIri, expand('dcterms:identifier'), null).map(q => q.value);
+    expect(ids).toContain('test');
+  });
+
+  it('emits a dcat:Distribution blank per distribution with mediaType and downloadURL', () => {
+    const input = makeInput();
+    const graph = emitDatasetGraph(input);
+    const store = parseTurtle(writeTurtle(graph));
+    const dists = store.getObjects(input.datasetIri, expand('dcat:distribution'), null);
+    expect(dists.length).toBe(2);
+
+    const ttlDist = dists.find(d => {
+      const types = store.getObjects(d, expand('rdf:type'), null).map(q => q.value);
+      const mediaTypes = store.getObjects(d, expand('dcat:mediaType'), null).map(q => q.value);
+      return types.includes(expand('dcat:Distribution')) && mediaTypes.includes('text/turtle');
+    });
+    expect(ttlDist).toBeDefined();
+
+    const downloadUrls = store.getObjects(ttlDist!, expand('dcat:downloadURL'), null).map(q => q.value);
+    expect(downloadUrls).toContain('https://glossarist.org/data/test.ttl');
+
+    const byteSizes = store.getObjects(ttlDist!, expand('dcat:byteSize'), null).map(q => q.value);
+    expect(byteSizes).toContain('12345');
+  });
+
+  it('emits skos:hasTopConcept for every top-level concept', () => {
+    const input = makeInput();
+    const graph = emitDatasetGraph(input);
+    const store = parseTurtle(writeTurtle(graph));
+    const tops = store.getObjects(input.datasetIri, expand('skos:hasTopConcept'), null).map(q => q.value);
+    expect(tops).toContain(`${DATASET_BASE}/test/concept/1`);
+    expect(tops).toContain(`${DATASET_BASE}/test/concept/2`);
+  });
+
+  it('emits dcterms:language IRIs for every language', () => {
+    const input = makeInput();
+    const graph = emitDatasetGraph(input);
+    const store = parseTurtle(writeTurtle(graph));
+    const langs = store.getObjects(input.datasetIri, expand('dcterms:language'), null).map(q => q.value);
+    expect(langs).toContain('http://id.loc.gov/vocabulary/iso639-1/eng');
+    expect(langs).toContain('http://id.loc.gov/vocabulary/iso639-1/fra');
+  });
+
+  it('emits prov:wasDerivedFrom, publisher, and contactPoint when provided', () => {
+    const input = makeInput();
+    const graph = emitDatasetGraph(input);
+    const store = parseTurtle(writeTurtle(graph));
+    const derived = store.getObjects(input.datasetIri, expand('prov:wasDerivedFrom'), null).map(q => q.value);
+    const publishers = store.getObjects(input.datasetIri, expand('dcterms:publisher'), null).map(q => q.value);
+    const contacts = store.getObjects(input.datasetIri, expand('dcat:contactPoint'), null).map(q => q.value);
+    expect(derived).toContain('https://github.com/example/test');
+    expect(publishers).toContain('https://glossarist.org/agent/test-publisher');
+    expect(contacts).toContain('https://glossarist.org/agent/test-contact');
+  });
+});
+
+describe('emitDatasetGraph — J5 skos:Collection per section', () => {
+  it('emits a skos:Collection per section with skos:member entries', () => {
+    const input = makeInput({
+      sections: [
+        {
+          collectionIri: `${DATASET_BASE}/test/section/1-1`,
+          title: 'Section 1.1',
+          memberUris: [`${DATASET_BASE}/test/concept/1`],
+        },
+        {
+          collectionIri: `${DATASET_BASE}/test/section/1-2`,
+          title: 'Section 1.2',
+          memberUris: [`${DATASET_BASE}/test/concept/2`, `${DATASET_BASE}/test/concept/3`],
+        },
+      ],
+    });
+    const graph = emitDatasetGraph(input);
+    const store = parseTurtle(writeTurtle(graph));
+
+    for (const section of input.sections) {
+      const types = store.getObjects(section.collectionIri, expand('rdf:type'), null).map(q => q.value);
+      expect(types).toContain(expand('skos:Collection'));
+      const titles = store.getObjects(section.collectionIri, expand('dcterms:title'), null).map(q => q.value);
+      expect(titles).toContain(section.title);
+      const members = store.getObjects(section.collectionIri, expand('skos:member'), null).map(q => q.value);
+      for (const member of section.memberUris) {
+        expect(members).toContain(member);
+      }
+    }
+  });
+
+  it('omits collections when sections array is empty', () => {
+    const input = makeInput({ sections: [] });
+    const graph = emitDatasetGraph(input);
+    const ttl = writeTurtle(graph);
+    expect(ttl).not.toMatch(/skos:Collection/);
+  });
+
+  it('emits gloss:hasParentSection and gloss:hasChildSection for hierarchical sections', () => {
+    const root = `${DATASET_BASE}/test/section/3`;
+    const mid = `${DATASET_BASE}/test/section/3-1`;
+    const leaf = `${DATASET_BASE}/test/section/3-1-1`;
+    const input = makeInput({
+      sections: [
+        { collectionIri: root, title: 'Section 3', memberUris: [], childCollectionIris: [mid] },
+        { collectionIri: mid, title: 'Section 3.1', memberUris: [], parentCollectionIri: root, childCollectionIris: [leaf] },
+        { collectionIri: leaf, title: 'Section 3.1.1', memberUris: [], parentCollectionIri: mid },
+      ],
+    });
+    const graph = emitDatasetGraph(input);
+    const store = parseTurtle(writeTurtle(graph));
+
+    const midChildren = store.getObjects(mid, 'https://www.glossarist.org/ontologies/hasChildSection', null).map(q => q.value);
+    expect(midChildren).toContain(leaf);
+
+    const midParent = store.getObjects(mid, 'https://www.glossarist.org/ontologies/hasParentSection', null).map(q => q.value);
+    expect(midParent).toContain(root);
+
+    const leafParent = store.getObjects(leaf, 'https://www.glossarist.org/ontologies/hasParentSection', null).map(q => q.value);
+    expect(leafParent).toContain(mid);
+
+    const rootParent = store.getObjects(root, 'https://www.glossarist.org/ontologies/hasParentSection', null);
+    expect(rootParent.length).toBe(0);
+  });
+});
+
+describe('emitDatasetGraph — JSON-LD output', () => {
+  it('produces a parseable JSON-LD document with the dataset node', () => {
+    const input = makeInput();
+    const graph = emitDatasetGraph(input);
+    const doc = JSON.parse(writeJsonLd(graph));
+    const datasetNode = doc['@graph'].find((n: any) =>
+      Array.isArray(n['@type']) && n['@type'].includes('dcat:Dataset'),
+    );
+    expect(datasetNode).toBeDefined();
+    expect(datasetNode['@id']).toBe(input.datasetIri);
+    expect(datasetNode['dcterms:title']).toBe('Test Glossary');
+    const types = datasetNode['@type'];
+    expect(types).toContain('skos:ConceptScheme');
+  });
+});

package/src/__tests__/concept-rdf/differential.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Parser, Store, DataFactory } from 'n3';
+import { Concept } from 'glossarist';
+import { emitConceptGraph } from '../../components/concept-rdf/concept-emitter';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { CONCEPT_FIXTURES } from '../__fixtures__/concepts';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const RUBY_SNAPSHOTS_PATH = resolve(
+  __dirname,
+  '..',
+  '..',
+  '..',
+  'node_modules',
+  '@glossarist',
+  'concept-model',
+  'test',
+  'snapshots',
+  'ruby',
+);
+
+const HAVE_SNAPSHOTS = existsSync(RUBY_SNAPSHOTS_PATH);
+
+function parseTurtle(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+interface QuadSet {
+  readonly size: number;
+  readonly quads: ReadonlySet<string>;
+}
+
+function canonicalizeQuadSet(store: Store): QuadSet {
+  const quads = new Set<string>();
+  store.forEach(q => {
+    quads.add(`${q.subject.value}|${q.predicate.value}|${q.object.value}|${q.object.termType}`);
+  });
+  return { size: quads.size, quads };
+}
+
+describe.skipIf(!HAVE_SNAPSHOTS)('WS P1 — differential testing (JS vs Ruby snapshots)', () => {
+  for (const fixture of CONCEPT_FIXTURES) {
+    it(`${fixture.name}: JS Turtle is graph-isomorphic to the Ruby snapshot`, () => {
+      const jsTtl = writeTurtle(emitConceptGraph(fixture.concept, fixture.uri).graph);
+      const rubyPath = join(RUBY_SNAPSHOTS_PATH, `${fixture.name}.ttl`);
+      const rubyTtl = readFileSync(rubyPath, 'utf8');
+
+      const jsStore = parseTurtle(jsTtl);
+      const rubyStore = parseTurtle(rubyTtl);
+
+      const jsSet = canonicalizeQuadSet(jsStore);
+      const rubySet = canonicalizeQuadSet(rubyStore);
+
+      if (jsSet.size !== rubySet.size) {
+        const jsOnly = [...jsSet.quads].filter(q => !rubySet.quads.has(q));
+        const rubyOnly = [...rubySet.quads].filter(q => !jsSet.quads.has(q));
+        expect.fail(
+          `Quad count mismatch for ${fixture.name}.\n` +
+          `JS-only (${jsOnly.length}):\n${jsOnly.slice(0, 20).join('\n')}\n` +
+          `Ruby-only (${rubyOnly.length}):\n${rubyOnly.slice(0, 20).join('\n')}`,
+        );
+      }
+      expect(jsSet.size).toBe(rubySet.size);
+    });
+  }
+});
+
+describe('WS P1 — differential test scaffolding', () => {
+  it('reports whether Ruby snapshots are present', () => {
+    if (!HAVE_SNAPSHOTS) {
+      // eslint-disable-next-line no-console
+      console.log(
+        `P1: Ruby snapshots not found at ${RUBY_SNAPSHOTS_PATH}.\n` +
+        `Once concept-model publishes @glossarist/concept-model/test-fixtures with snapshots/ruby/,\n` +
+        `this test will run byte-equivalence / graph-isomorphism assertions against them.\n` +
+        `Until then, the suite passes conditionally and the scaffolding is ready.`,
+      );
+    }
+    expect(typeof HAVE_SNAPSHOTS).toBe('boolean');
+  });
+
+  it('emits a parseable Turtle for every fixture (smoke check)', () => {
+    for (const fixture of CONCEPT_FIXTURES) {
+      const jsTtl = writeTurtle(emitConceptGraph(fixture.concept, fixture.uri).graph);
+      const store = parseTurtle(jsTtl);
+      expect(store.size).toBeGreaterThan(0);
+    }
+  });
+});