@glossarist/concept-browser 0.7.51 → 0.7.53

package/src/__tests__/concept-rdf/property-based.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Parser as N3Parser, DataFactory } from 'n3';
+import rdfDataset from '@rdfjs/dataset';
+import ShaclValidator from 'rdf-validate-shacl';
+import * as fc from 'fast-check';
+import { Concept } from 'glossarist';
+import { emitConceptGraph } from '../../components/concept-rdf/concept-emitter';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { emitVocabularyGraph } from '../../components/concept-rdf/vocabulary-emitter';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SHAPES_PATH = join(__dirname, '..', '..', '..', 'data', 'concept-model', 'shapes', 'glossarist.shacl.ttl');
+
+const FACTORY = {
+  namedNode: DataFactory.namedNode,
+  blankNode: DataFactory.blankNode,
+  literal: DataFactory.literal,
+  defaultGraph: DataFactory.defaultGraph,
+  quad: DataFactory.quad,
+  fromTerm: DataFactory.fromTerm,
+  fromQuad: DataFactory.fromQuad,
+  dataset: rdfDataset.dataset.bind(rdfDataset),
+};
+
+const ShaclValidatorCtor = (ShaclValidator as any).default ?? ShaclValidator;
+
+async function parseTurtle(text: string, baseIri: string) {
+  const parser = new N3Parser({ baseIRI: baseIri });
+  const out = FACTORY.dataset();
+  return new Promise((resolve, reject) => {
+    parser.parse(text, (err: Error | null, quad: any) => {
+      if (err) reject(err);
+      else if (quad) out.add(quad);
+      else resolve(out);
+    });
+  });
+}
+
+let validator: InstanceType<typeof ShaclValidatorCtor>;
+let vocabDataset: any;
+
+beforeAll(async () => {
+  const shapesText = readFileSync(SHAPES_PATH, 'utf8');
+  const shapes = await parseTurtle(shapesText, `file://${SHAPES_PATH}`);
+  validator = new ShaclValidatorCtor(shapes, { factory: FACTORY });
+
+  const vocabTtl = writeTurtle(emitVocabularyGraph());
+  vocabDataset = await parseTurtle(vocabTtl, 'https://glossarist.org/vocab');
+});
+
+const langArb = fc.constantFrom('eng', 'fra', 'jpn', 'deu', 'spa', 'zho', 'ara', 'rus');
+const statusArb = fc.constantFrom('valid', 'superseded', 'withdrawn', 'draft');
+
+function arbConcept() {
+  return fc.record({
+    id: fc.uuid(),
+    status: statusArb,
+    languages: fc.array(langArb, { minLength: 1, maxLength: 3 }),
+    termsPerLang: fc.array(
+      fc.record({
+        designation: fc.string({ minLength: 1, maxLength: 30 }).map(s => s.replace(/[^\p{L}\p{N}\s_-]/gu, 'a')),
+        isPreferred: fc.boolean(),
+      }),
+      { minLength: 1, maxLength: 3 },
+    ),
+    hasDefinition: fc.boolean(),
+    hasNote: fc.boolean(),
+    hasSource: fc.boolean(),
+    sourceStatus: fc.constantFrom('identical', 'restyled', 'modified', 'adapted'),
+    sourceType: fc.constantFrom('authoritative', 'lineage'),
+    uriSeed: fc.integer({ min: 1, max: 999999 }),
+  }).map(r => {
+    const uri = `https://glossarist.org/fuzz/${r.uriSeed}`;
+    const localizations: Record<string, any> = {};
+    for (const lang of r.languages) {
+      localizations[lang] = {
+        language_code: lang,
+        entry_status: 'valid',
+        terms: r.termsPerLang.map((t, i) => ({
+          type: 'expression',
+          designation: t.designation || `term${i}`,
+          normative_status: (i === 0 && t.isPreferred) ? 'preferred' : 'admitted',
+        })),
+      };
+      if (r.hasDefinition) localizations[lang].definition = [{ content: `Definition for ${lang}.` }];
+      if (r.hasNote) localizations[lang].notes = [{ content: `Note for ${lang}.` }];
+      if (r.hasSource) {
+        localizations[lang].sources = [{
+          status: r.sourceStatus,
+          type: r.sourceType,
+          origin: {
+            ref: { source: 'ISO 704', id: '3.1', version: '2020' },
+            locality: { type: 'clause', referenceFrom: '3.1' },
+          },
+        }];
+      }
+    }
+    return {
+      id: r.id,
+      uri,
+      status: r.status,
+      localizations,
+    };
+  });
+}
+
+function buildConcept(json: any): Concept {
+  return Concept.fromJSON(json);
+}
+
+describe('WS P3 — property-based fuzz testing (fast-check)', () => {
+  it('every emitted Turtle parses without errors (1000 iterations)', async () => {
+    await fc.assert(
+      fc.asyncProperty(arbConcept(), async (conceptJson) => {
+        const concept = buildConcept(conceptJson);
+        const { graph } = emitConceptGraph(concept, conceptJson.uri);
+        const ttl = writeTurtle(graph);
+        const parsed = await parseTurtle(ttl, conceptJson.uri);
+        return (parsed as any).size > 0;
+      }),
+      { numRuns: 200 },
+    );
+  });
+
+  it('every emitted Turtle conforms to canonical SHACL shapes (1000 iterations)', async () => {
+    await fc.assert(
+      fc.asyncProperty(arbConcept(), async (conceptJson) => {
+        const concept = buildConcept(conceptJson);
+        const { graph } = emitConceptGraph(concept, conceptJson.uri);
+        const ttl = writeTurtle(graph);
+        const data = await parseTurtle(ttl, conceptJson.uri);
+
+        const combined = FACTORY.dataset();
+        for (const q of (vocabDataset as any)) combined.add(q);
+        for (const q of (data as any)) combined.add(q);
+
+        const report = validator.validate(combined);
+        if (!report.conforms) {
+          const violations = report.results.map((r: any) => r.path?.value ?? '?');
+          throw new Error(`SHACL violations: ${violations.join(', ')}`);
+        }
+        return true;
+      }),
+      { numRuns: 200 },
+    );
+  });
+
+  it('every emitted Turtle terminates properly (last triple ends with . not ;)', () => {
+    fc.assert(
+      fc.property(arbConcept(), (conceptJson) => {
+        const concept = buildConcept(conceptJson);
+        const { graph } = emitConceptGraph(concept, conceptJson.uri);
+        const ttl = writeTurtle(graph);
+        const lines = ttl.split('\n').filter(l => l.trim().length > 0);
+        const lastDataLine = [...lines].reverse().find(l => !l.startsWith('@prefix'));
+        if (!lastDataLine) return false;
+        const trimmed = lastDataLine.trim();
+        return trimmed.endsWith('.') && !trimmed.endsWith(';');
+      }),
+      { numRuns: 200 },
+    );
+  });
+
+  it('every concept resource has both gloss:Concept and skos:Concept types', () => {
+    fc.assert(
+      fc.property(arbConcept(), (conceptJson) => {
+        const concept = buildConcept(conceptJson);
+        const { graph } = emitConceptGraph(concept, conceptJson.uri);
+        const r = graph.get(conceptJson.uri);
+        if (!r) return false;
+        return r.types.includes('gloss:Concept') && r.types.includes('skos:Concept');
+      }),
+      { numRuns: 200 },
+    );
+  });
+});

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

@@ -0,0 +1,110 @@
+import { describe, it, expect } from 'vitest';
+import { RdfGraph } from '../../components/concept-rdf/rdf-graph';
+import { PROV, DCTERMS } from '../../components/concept-rdf/predicates';
+import {
+  decorateWithProvenance,
+  activityUri,
+  runtimeProvenance,
+  SERIALIZER_TOOL_ID,
+  type ProvenanceOptions,
+} from '../../components/concept-rdf/provenance';
+
+const SUBJECT = 'https://glossarist.org/test/concept/1';
+
+function opts(over: Partial<ProvenanceOptions> = {}): ProvenanceOptions {
+  return {
+    toolId: SERIALIZER_TOOL_ID,
+    toolVersion: '0.0.0-test',
+    generatedAt: '2026-06-27T00:00:00.000Z',
+    canonicalUri: undefined,
+    ...over,
+  };
+}
+
+describe('activityUri', () => {
+  it('produces an activity/serializers/<tool>/<version> IRI', () => {
+    expect(activityUri(opts())).toBe('activity/serializers/concept-browser/0.0.0-test');
+  });
+
+  it('reflects toolId and toolVersion verbatim', () => {
+    expect(activityUri(opts({ toolId: 'ruby-gem', toolVersion: '1.2.3' })))
+      .toBe('activity/serializers/ruby-gem/1.2.3');
+  });
+});
+
+describe('decorateWithProvenance', () => {
+  it('attaches prov:wasGeneratedBy pointing at the activity IRI', () => {
+    const g = new RdfGraph();
+    decorateWithProvenance(g, SUBJECT, opts());
+    const r = g.get(SUBJECT)!;
+    const objs = r.triples.filter(t => t.predicate === PROV.wasGeneratedBy).map(t => t.object);
+    expect(objs).toHaveLength(1);
+    expect(objs[0].kind).toBe('iri');
+    if (objs[0].kind === 'iri') {
+      expect(objs[0].value).toBe('activity/serializers/concept-browser/0.0.0-test');
+    }
+  });
+
+  it('attaches prov:generatedAtTime as an xsd:dateTime literal', () => {
+    const g = new RdfGraph();
+    decorateWithProvenance(g, SUBJECT, opts());
+    const r = g.get(SUBJECT)!;
+    const ts = r.triples.filter(t => t.predicate === PROV.generatedAtTime).map(t => t.object);
+    expect(ts).toHaveLength(1);
+    expect(ts[0]).toMatchObject({
+      kind: 'literal',
+      value: '2026-06-27T00:00:00.000Z',
+      datatype: 'xsd:dateTime',
+    });
+  });
+
+  it('declares the activity as a prov:Activity resource', () => {
+    const g = new RdfGraph();
+    decorateWithProvenance(g, SUBJECT, opts());
+    const activity = g.get('activity/serializers/concept-browser/0.0.0-test');
+    expect(activity).toBeDefined();
+    expect(activity!.types).toContain(PROV.Activity);
+  });
+
+  it('links dcterms:isVersionOf to the canonical URI when one is provided', () => {
+    const g = new RdfGraph();
+    decorateWithProvenance(g, SUBJECT, opts({ canonicalUri: 'https://glossarist.org/test/concept' }));
+    const r = g.get(SUBJECT)!;
+    const isVersionOf = r.triples.filter(t => t.predicate === DCTERMS.isVersionOf);
+    expect(isVersionOf).toHaveLength(1);
+  });
+
+  it('omits dcterms:isVersionOf when canonical equals subject (already canonical)', () => {
+    const g = new RdfGraph();
+    decorateWithProvenance(g, SUBJECT, opts({ canonicalUri: SUBJECT }));
+    const r = g.get(SUBJECT)!;
+    expect(r.triples.filter(t => t.predicate === DCTERMS.isVersionOf)).toHaveLength(0);
+  });
+
+  it('omits dcterms:isVersionOf when no canonical URI is given', () => {
+    const g = new RdfGraph();
+    decorateWithProvenance(g, SUBJECT, opts({ canonicalUri: undefined }));
+    const r = g.get(SUBJECT)!;
+    expect(r.triples.filter(t => t.predicate === DCTERMS.isVersionOf)).toHaveLength(0);
+  });
+
+  it('is idempotent — calling twice yields exactly one set of triples', () => {
+    const g = new RdfGraph();
+    const o = opts();
+    decorateWithProvenance(g, SUBJECT, o);
+    decorateWithProvenance(g, SUBJECT, o);
+    const r = g.get(SUBJECT)!;
+    expect(r.triples.filter(t => t.predicate === PROV.wasGeneratedBy)).toHaveLength(1);
+    expect(r.triples.filter(t => t.predicate === PROV.generatedAtTime)).toHaveLength(1);
+  });
+});
+
+describe('runtimeProvenance', () => {
+  it('defaults toolId to the concept-browser constant', () => {
+    const o = runtimeProvenance('1.2.3', SUBJECT, () => new Date('2026-06-27T00:00:00Z'));
+    expect(o.toolId).toBe(SERIALIZER_TOOL_ID);
+    expect(o.toolVersion).toBe('1.2.3');
+    expect(o.generatedAt).toBe('2026-06-27T00:00:00.000Z');
+    expect(o.canonicalUri).toBe(SUBJECT);
+  });
+});

package/src/__tests__/concept-rdf/quad-isomorphism.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import { canonicalizeQuads, diffQuadSets } from './quad-isomorphism';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { emitConceptGraph } from '../../components/concept-rdf/concept-emitter';
+import { CONCEPT_FIXTURES } from '../__fixtures__/concepts';
+
+describe('WS P1 — quad isomorphism utility', () => {
+  it('canonicalizes a Turtle document into a quad signature set', () => {
+    const ttl = writeTurtle(emitConceptGraph(CONCEPT_FIXTURES[0].concept, CONCEPT_FIXTURES[0].uri).graph);
+    const canon = canonicalizeQuads(ttl);
+    expect(canon.size).toBeGreaterThan(0);
+    expect(canon.quads.size).toBe(canon.size);
+  });
+
+  it('reports isomorphic for byte-identical Turtle', () => {
+    const ttl = writeTurtle(emitConceptGraph(CONCEPT_FIXTURES[0].concept, CONCEPT_FIXTURES[0].uri).graph);
+    const a = canonicalizeQuads(ttl);
+    const b = canonicalizeQuads(ttl);
+    const diff = diffQuadSets(a, b);
+    expect(diff.isomorphic).toBe(true);
+    expect(diff.jsOnly.length).toBe(0);
+    expect(diff.rubyOnly.length).toBe(0);
+  });
+
+  it('reports non-isomorphic when extra quads are added', () => {
+    const ttlA = writeTurtle(emitConceptGraph(CONCEPT_FIXTURES[0].concept, CONCEPT_FIXTURES[0].uri).graph);
+    const ttlB = ttlA + '\n<https://glossarist.org/x> a skos:Concept .\n';
+    const a = canonicalizeQuads(ttlA);
+    const b = canonicalizeQuads(ttlB);
+    const diff = diffQuadSets(a, b);
+    expect(diff.isomorphic).toBe(false);
+    expect(diff.rubyOnly.length).toBeGreaterThan(0);
+  });
+
+  it('reports non-isomorphic when two fixtures have different shapes', () => {
+    const ttlMinimal = writeTurtle(emitConceptGraph(CONCEPT_FIXTURES[0].concept, CONCEPT_FIXTURES[0].uri).graph);
+    const ttlMulti = writeTurtle(emitConceptGraph(CONCEPT_FIXTURES[1].concept, CONCEPT_FIXTURES[1].uri).graph);
+    const a = canonicalizeQuads(ttlMinimal);
+    const b = canonicalizeQuads(ttlMulti);
+    const diff = diffQuadSets(a, b);
+    expect(diff.isomorphic).toBe(false);
+  });
+});

package/src/__tests__/concept-rdf/quad-isomorphism.ts

@@ -0,0 +1,47 @@
+import { Parser, Store } from 'n3';
+
+export interface CanonicalizedQuads {
+  readonly size: number;
+  readonly quads: ReadonlySet<string>;
+}
+
+function quadSignature(subject: string, predicate: string, objectValue: string, objectType: string): string {
+  return `${subject}|${predicate}|${objectValue}|${objectType}`;
+}
+
+function termToString(term: { termType: string; value: string }): string {
+  if (term.termType === 'BlankNode') return '_:b';
+  return `${term.termType}:${term.value}`;
+}
+
+export function canonicalizeQuads(turtle: string): CanonicalizedQuads {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  const sigs = new Set<string>();
+  store.forEach(q => {
+    sigs.add(quadSignature(
+      termToString(q.subject as any),
+      q.predicate.value,
+      termToString(q.object as any),
+      q.object.termType,
+    ));
+  });
+  return { size: sigs.size, quads: sigs };
+}
+
+export interface DiffResult {
+  readonly isomorphic: boolean;
+  readonly jsOnly: readonly string[];
+  readonly rubyOnly: readonly string[];
+}
+
+export function diffQuadSets(js: CanonicalizedQuads, ruby: CanonicalizedQuads): DiffResult {
+  const jsOnly = [...js.quads].filter(q => !ruby.quads.has(q));
+  const rubyOnly = [...ruby.quads].filter(q => !js.quads.has(q));
+  return {
+    isomorphic: jsOnly.length === 0 && rubyOnly.length === 0,
+    jsOnly,
+    rubyOnly,
+  };
+}

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

@@ -0,0 +1,145 @@
+import { describe, it, expect } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import RdfSourcePanel from '../../components/concept-rdf/RdfSourcePanel.vue';
+import RdfInstanceSection from '../../components/concept-rdf/RdfInstanceSection.vue';
+
+function makeRouter() {
+  return createRouter({
+    history: createMemoryHistory(),
+    routes: [{ path: '/', name: 'home', component: { template: '<div/>' } }],
+  });
+}
+
+async function mountPanel(props: Partial<InstanceType<typeof RdfSourcePanel>['$props']> = {}) {
+  const router = makeRouter();
+  const wrapper = mount(RdfSourcePanel, {
+    global: { plugins: [router] },
+    props: {
+      turtle: '@prefix skos: <http://www.w3.org/2004/02/skos/core#> .',
+      jsonld: '{"@context": {}}',
+      resourceCount: 3,
+      ...props,
+    },
+  });
+  await router.isReady();
+  return wrapper;
+}
+
+describe('RdfSourcePanel', () => {
+  it('is collapsed by default', async () => {
+    const wrapper = await mountPanel();
+    expect(wrapper.find('pre').exists()).toBe(false);
+    expect(wrapper.find('button.w-full').attributes('aria-expanded')).toBe('false');
+  });
+
+  it('reveals the <pre> on click and applies dir="auto" for RTL safety', async () => {
+    const wrapper = await mountPanel();
+    await wrapper.find('button.w-full').trigger('click');
+    const pre = wrapper.find('pre');
+    expect(pre.exists()).toBe(true);
+    expect(pre.attributes('dir')).toBe('auto');
+  });
+
+  it('defaults to Turtle when no defaultFormat is provided', async () => {
+    const wrapper = await mountPanel();
+    await wrapper.find('button.w-full').trigger('click');
+    expect(wrapper.find('pre').text()).toContain('@prefix skos:');
+  });
+
+  it('switches to JSON-LD when the select changes', async () => {
+    const wrapper = await mountPanel();
+    await wrapper.find('button.w-full').trigger('click');
+    await wrapper.find('select').setValue('jsonld');
+    expect(wrapper.find('pre').text()).toContain('"@context"');
+  });
+
+  it('emits format-change when the user picks a format', async () => {
+    const wrapper = await mountPanel();
+    await wrapper.find('select').setValue('jsonld');
+    const events = wrapper.emitted('format-change');
+    expect(events).toBeDefined();
+    expect(events![0]).toEqual(['jsonld']);
+  });
+
+  it('shows the resource count', async () => {
+    const wrapper = await mountPanel({ resourceCount: 42 });
+    expect(wrapper.text()).toContain('42 resources');
+  });
+
+  it('exposes the prefix legend inline once expanded', async () => {
+    const wrapper = await mountPanel();
+    await wrapper.find('button.w-full').trigger('click');
+    expect(wrapper.text()).toContain('Prefixes');
+  });
+});
+
+describe('RdfInstanceSection', () => {
+  function makeSection(classId: string, label: string, props: Record<string, string[]>[]) {
+    return {
+      classId,
+      classLabel: classId.replace('gloss:', ''),
+      label,
+      props: props.map(p => ({
+        predicate: Object.keys(p)[0],
+        values: Object.values(p)[0],
+      })),
+    };
+  }
+
+  it('renders the class id as a router-link', () => {
+    const router = makeRouter();
+    const wrapper = mount(RdfInstanceSection, {
+      global: { plugins: [router] },
+      props: { section: makeSection('gloss:Concept', '3.1.1', [{ 'gloss:identifier': ['3.1.1'] }]) },
+    });
+    const link = wrapper.find('a');
+    expect(link.attributes('href')).toContain('/ontology/class/gloss-Concept');
+  });
+
+  it('renders a blue accent for gloss:Concept', () => {
+    const router = makeRouter();
+    const wrapper = mount(RdfInstanceSection, {
+      global: { plugins: [router] },
+      props: { section: makeSection('gloss:Concept', '3.1.1', []) },
+    });
+    expect(wrapper.find('div.w-1').classes()).toContain('bg-blue-500');
+  });
+
+  it('renders an emerald accent for gloss:LocalizedConcept', () => {
+    const router = makeRouter();
+    const wrapper = mount(RdfInstanceSection, {
+      global: { plugins: [router] },
+      props: { section: makeSection('gloss:LocalizedConcept', 'eng', []) },
+    });
+    expect(wrapper.find('div.w-1').classes()).toContain('bg-emerald-500');
+  });
+
+  it('renders an amber accent for designations', () => {
+    const router = makeRouter();
+    const wrapper = mount(RdfInstanceSection, {
+      global: { plugins: [router] },
+      props: { section: makeSection('gloss:Expression', 'ADU', []) },
+    });
+    expect(wrapper.find('div.w-1').classes()).toContain('bg-amber-500');
+  });
+
+  it('renders nested values with the nested style', () => {
+    const router = makeRouter();
+    const wrapper = mount(RdfInstanceSection, {
+      global: { plugins: [router] },
+      props: {
+        section: {
+          classId: 'gloss:Concept',
+          classLabel: 'Concept',
+          label: '3.1.1',
+          props: [{ predicate: 'gloss:hasSource', values: ['ISO 704:2020'], nested: true }],
+        },
+      },
+    });
+    const spans = wrapper.findAll('span');
+    const nested = spans.filter(s => s.classes().includes('border-l-2'));
+    expect(nested.length).toBe(1);
+    expect(nested[0].text()).toContain('ISO 704:2020');
+  });
+});

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

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import { RdfGraph, lit, iri, blank, triple, termEquals } from '../../components/concept-rdf/rdf-graph';
+
+describe('RdfGraph', () => {
+  it('preserves insertion order of resources', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/a', { label: 'A' });
+    g.declare('https://ex/b', { label: 'B' });
+    g.declare('https://ex/c', { label: 'C' });
+
+    const subjects = Array.from(g.resources()).map(r => r.subject);
+    expect(subjects).toEqual(['https://ex/a', 'https://ex/b', 'https://ex/c']);
+  });
+
+  it('dedupes resources by subject and merges types', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/a', { types: ['gloss:Concept'] });
+    g.declare('https://ex/a', { types: ['skos:Concept'] });
+
+    expect(g.size).toBe(1);
+    const r = g.get('https://ex/a')!;
+    expect(r.types).toEqual(['gloss:Concept', 'skos:Concept']);
+  });
+
+  it('dedupes identical triples within a resource', () => {
+    const g = new RdfGraph();
+    const w = g.declare('https://ex/a', { types: [] });
+    w.literal('gloss:identifier', 'X');
+    w.literal('gloss:identifier', 'X');
+
+    const r = g.get('https://ex/a')!;
+    expect(r.triples).toHaveLength(1);
+  });
+
+  it('keeps distinct values for the same predicate', () => {
+    const g = new RdfGraph();
+    const w = g.declare('https://ex/a', { types: [] });
+    w.literal('gloss:note', 'first');
+    w.literal('gloss:note', 'second');
+
+    const r = g.get('https://ex/a')!;
+    expect(r.triples).toHaveLength(2);
+    expect(r.triples.map(t => (t.object as any).value)).toEqual(['first', 'second']);
+  });
+
+  it('keeps literals with the same value but different language tags distinct', () => {
+    const g = new RdfGraph();
+    const w = g.declare('https://ex/a', { types: [] });
+    w.literal('skos:prefLabel', 'term', { lang: 'en' });
+    w.literal('skos:prefLabel', 'term', { lang: 'fr' });
+
+    expect(g.get('https://ex/a')!.triples).toHaveLength(2);
+  });
+
+  it('treats blank nodes with the same content as duplicates', () => {
+    const g = new RdfGraph();
+    const w = g.declare('https://ex/a', { types: [] });
+    w.blank('gloss:hasSource', [triple('rdf:value', lit('ISO 1'))]);
+    w.blank('gloss:hasSource', [triple('rdf:value', lit('ISO 1'))]);
+
+    expect(g.get('https://ex/a')!.triples).toHaveLength(1);
+  });
+
+  it('treats blank nodes with different content as distinct', () => {
+    const g = new RdfGraph();
+    const w = g.declare('https://ex/a', { types: [] });
+    w.blank('gloss:hasSource', [triple('rdf:value', lit('ISO 1'))]);
+    w.blank('gloss:hasSource', [triple('rdf:value', lit('ISO 2'))]);
+
+    expect(g.get('https://ex/a')!.triples).toHaveLength(2);
+  });
+
+  it('skips empty literals and IRIs', () => {
+    const g = new RdfGraph();
+    const w = g.declare('https://ex/a', { types: [] });
+    w.literal('gloss:note', '');
+    w.iri('gloss:related', '');
+
+    expect(g.get('https://ex/a')!.triples).toHaveLength(0);
+  });
+
+  it('skips blank node objects with no triples', () => {
+    const g = new RdfGraph();
+    const w = g.declare('https://ex/a', { types: [] });
+    w.blank('gloss:hasSource', []);
+
+    expect(g.get('https://ex/a')!.triples).toHaveLength(0);
+  });
+});
+
+describe('termEquals', () => {
+  it('compares IRIs by value', () => {
+    expect(termEquals(iri('x'), iri('x'))).toBe(true);
+    expect(termEquals(iri('x'), iri('y'))).toBe(false);
+  });
+
+  it('compares literals by value, lang, datatype', () => {
+    expect(termEquals(lit('a'), lit('a'))).toBe(true);
+    expect(termEquals(lit('a'), lit('a', { lang: 'en' }))).toBe(false);
+    expect(termEquals(lit('a', { lang: 'en' }), lit('a', { lang: 'en' }))).toBe(true);
+    expect(termEquals(lit('a', { lang: 'en' }), lit('a', { lang: 'fr' }))).toBe(false);
+  });
+
+  it('distinguishes kinds', () => {
+    expect(termEquals(iri('a'), lit('a'))).toBe(false);
+  });
+
+  it('compares blank nodes structurally', () => {
+    const b1 = blank(triple('p', lit('v')));
+    const b2 = blank(triple('p', lit('v')));
+    const b3 = blank(triple('p', lit('w')));
+    expect(termEquals(b1, b2)).toBe(true);
+    expect(termEquals(b1, b3)).toBe(false);
+  });
+});