@glossarist/concept-browser 0.7.51 → 0.7.53

package/src/components/SidebarSeriesSection.vue

@@ -0,0 +1,239 @@
+<script setup lang="ts">
+/**
+ * SidebarSeriesSection — compact version of the dataset series list for the
+ * AppSidebar. Shows all multi-edition series as collapsible groups with their
+ * editions as clickable items.
+ *
+ * Designed to fit the sidebar's existing visual language: small text, gold
+ * accents, ink-100 borders. Uses Tailwind dark: classes for theme switching.
+ */
+import { computed, ref } from 'vue';
+import { useRouter } from 'vue-router';
+import { useDatasetSeries } from '../composables/useDatasetSeries';
+
+const router = useRouter();
+const { series } = useDatasetSeries();
+
+const multiEditionSeries = computed(() =>
+  series.value.filter(s => s.members.length > 1)
+);
+
+/* Collapse state — start expanded for the active series, collapsed otherwise */
+const collapsed = ref<Set<string>>(new Set());
+function toggle(key: string) {
+  const next = new Set(collapsed.value);
+  if (next.has(key)) next.delete(key);
+  else next.add(key);
+  collapsed.value = next;
+}
+function isCollapsed(key: string) {
+  return collapsed.value.has(key);
+}
+
+function navigate(registerId: string) {
+  router.push({ name: 'dataset', params: { registerId } });
+}
+</script>
+
+<template>
+  <div v-if="multiEditionSeries.length" class="sidebar-series">
+    <div class="section-label">Edition Series</div>
+    <div class="series-list">
+      <div v-for="s in multiEditionSeries" :key="s.key" class="series-block">
+        <button
+          class="series-header"
+          @click="toggle(s.key)"
+        >
+          <span class="series-chevron">{{ isCollapsed(s.key) ? '▸' : '▾' }}</span>
+          <span class="series-title">{{ s.title }}</span>
+          <span class="series-count">{{ s.members.length }}</span>
+        </button>
+        <ol v-if="!isCollapsed(s.key)" class="series-editions">
+          <li
+            v-for="member in [...s.members].reverse()"
+            :key="member.id"
+            :class="['edition-row', { active: member.isActive, current: member.isCurrent }]"
+          >
+            <button class="edition-button" @click="navigate(member.id)">
+              <span class="edition-year">{{ member.year ?? '—' }}</span>
+              <span class="edition-meta">
+                <span v-if="member.isActive" class="edition-mark">●</span>
+                <span v-else-if="member.isCurrent" class="edition-mark current">◆</span>
+              </span>
+            </button>
+          </li>
+        </ol>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.sidebar-series {
+  margin-bottom: 1.5rem;
+}
+.section-label {
+  font-size: 10px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.18em;
+  color: theme('colors.ink.300');
+  margin-bottom: 0.5rem;
+}
+:global(.dark) .section-label {
+  color: theme('colors.ink.400');
+}
+
+.series-list {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+}
+
+.series-block {
+  border-radius: 6px;
+}
+
+.series-header {
+  display: flex;
+  align-items: center;
+  gap: 0.375rem;
+  width: 100%;
+  padding: 0.375rem 0.5rem;
+  background: transparent;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  font-family: inherit;
+  text-align: left;
+  color: theme('colors.ink.700');
+  font-size: 12px;
+  font-weight: 600;
+  transition: background 0.15s;
+}
+.series-header:hover {
+  background: theme('colors.ink.50');
+}
+:global(.dark) .series-header {
+  color: theme('colors.ink.200');
+}
+:global(.dark) .series-header:hover {
+  background: theme('colors.ink.700');
+}
+.series-chevron {
+  font-size: 10px;
+  width: 0.625rem;
+  color: theme('colors.ink.300');
+}
+.series-title {
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-family: 'DM Serif Display', Georgia, serif;
+  font-size: 13px;
+  font-weight: 400;
+  letter-spacing: -0.005em;
+}
+.series-count {
+  font-family: 'JetBrains Mono', monospace;
+  font-size: 10px;
+  color: theme('colors.ink.300');
+  background: theme('colors.ink.50');
+  padding: 1px 6px;
+  border-radius: 8px;
+  font-weight: 600;
+}
+:global(.dark) .series-count {
+  background: theme('colors.ink.700');
+  color: theme('colors.ink.300');
+}
+
+.series-editions {
+  list-style: none;
+  padding: 0 0 0 0.625rem;
+  margin: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+}
+
+.edition-row {
+  position: relative;
+}
+
+.edition-button {
+  display: flex;
+  align-items: center;
+  gap: 0.375rem;
+  width: 100%;
+  padding: 0.25rem 0.5rem 0.25rem 0.875rem;
+  background: transparent;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  font-family: inherit;
+  text-align: left;
+  color: theme('colors.ink.500');
+  font-size: 11px;
+  transition: all 0.15s;
+  position: relative;
+}
+.edition-button::before {
+  content: '';
+  position: absolute;
+  left: 0;
+  top: 50%;
+  transform: translateY(-50%);
+  width: 4px;
+  height: 4px;
+  border-radius: 50%;
+  background: theme('colors.ink.200');
+}
+.edition-button:hover {
+  background: theme('colors.ink.50');
+  color: theme('colors.ink.800');
+}
+:global(.dark) .edition-button {
+  color: theme('colors.ink.400');
+}
+:global(.dark) .edition-button:hover {
+  background: theme('colors.ink.700');
+  color: theme('colors.ink.100');
+}
+
+.edition-row.active .edition-button {
+  color: #B8935A;
+  font-weight: 600;
+  background: rgba(184, 147, 90, 0.08);
+}
+.edition-row.active .edition-button::before {
+  background: #B8935A;
+  width: 5px;
+  height: 5px;
+  box-shadow: 0 0 0 2px rgba(184, 147, 90, 0.20);
+}
+.edition-row.current:not(.active) .edition-button::before {
+  background: #B8935A;
+}
+
+.edition-year {
+  font-family: 'JetBrains Mono', monospace;
+  font-size: 11px;
+  font-weight: 500;
+  letter-spacing: 0.02em;
+}
+.edition-meta {
+  margin-left: auto;
+  display: flex;
+  align-items: center;
+}
+.edition-mark {
+  font-size: 7px;
+  color: theme('colors.ink.300');
+}
+.edition-mark.current {
+  color: #B8935A;
+  font-size: 9px;
+}
+</style>

package/src/components/concept-rdf/RdfInstanceHeader.vue

@@ -0,0 +1,47 @@
+<script setup lang="ts">
+import { ref } from 'vue';
+
+const props = defineProps<{
+  uri: string;
+  conceptId: string;
+}>();
+
+defineEmits<{
+  (e: 'copy', uri: string): void;
+}>();
+
+const copied = ref(false);
+
+async function copy() {
+  try {
+    await navigator.clipboard.writeText(props.uri);
+  } catch {
+    // clipboard may be unavailable; ignore
+  }
+  copied.value = true;
+  setTimeout(() => { copied.value = false; }, 2000);
+}
+</script>
+
+<template>
+  <div class="min-w-0">
+    <div class="text-[10px] uppercase tracking-widest text-ink-300 font-medium mb-2">RDF Instance</div>
+    <div class="flex items-center gap-2 flex-wrap">
+      <code class="text-sm font-mono text-ink-700 break-all">{{ uri }}</code>
+      <button
+        type="button"
+        @click="copy"
+        class="p-1.5 rounded text-ink-300 hover:text-ink-600 hover:bg-ink-50 transition-colors flex-shrink-0"
+        :title="copied ? 'Copied!' : 'Copy URI'"
+        :aria-label="copied ? 'URI copied to clipboard' : 'Copy URI to clipboard'"
+      >
+        <svg v-if="!copied" class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 5H6a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2v-1M8 5a2 2 0 002 2h2a2 2 0 002-2M8 5a2 2 0 012-2h2a2 2 0 012 2m0 0h2a2 2 0 012 2v3m2 4H10a2 2 0 01-2-2v-1m6 4v-3a2 2 0 00-2-2H8"/></svg>
+        <svg v-else class="w-3.5 h-3.5 text-emerald-500" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/></svg>
+      </button>
+    </div>
+    <div class="flex gap-1.5 mt-2.5">
+      <router-link to="/ontology/class/gloss-Concept" class="inline-flex items-center px-2 py-0.5 rounded text-[11px] font-medium bg-blue-50 text-blue-700 border border-blue-100 hover:bg-blue-100 transition-colors">gloss:Concept</router-link>
+      <router-link to="/ontology/class/gloss-Concept" class="inline-flex items-center px-2 py-0.5 rounded text-[11px] font-medium bg-emerald-50 text-emerald-700 border border-emerald-100 hover:bg-emerald-100 transition-colors">skos:Concept</router-link>
+    </div>
+  </div>
+</template>

package/src/components/concept-rdf/RdfInstanceSection.vue

@@ -0,0 +1,54 @@
+<script setup lang="ts">
+import type { PropValue } from './use-rdf-document';
+
+defineProps<{
+  section: {
+    classId: string;
+    classLabel: string;
+    label: string;
+    props: PropValue[];
+  };
+}>();
+
+function accent(classId: string): string {
+  if (classId === 'gloss:Concept') return 'bg-blue-500';
+  if (classId === 'gloss:LocalizedConcept') return 'bg-emerald-500';
+  return 'bg-amber-500';
+}
+
+function classRoute(classId: string): string {
+  return `/ontology/class/${classId.replace(/:/g, '-')}`;
+}
+</script>
+
+<template>
+  <div class="card p-5">
+    <div class="flex items-center gap-2 mb-3">
+      <div class="w-1 h-4 rounded-full" :class="accent(section.classId)"></div>
+      <router-link :to="classRoute(section.classId)" class="text-xs font-semibold text-ink-700 hover:text-blue-600 transition-colors">{{ section.classId }}</router-link>
+      <span class="text-xs text-ink-400">·</span>
+      <span class="text-xs text-ink-500">{{ section.label }}</span>
+    </div>
+    <div class="space-y-1.5">
+      <div
+        v-for="prop in section.props"
+        :key="prop.predicate"
+        class="grid grid-cols-[160px_1fr] gap-x-3 gap-y-0.5 py-1.5 border-b border-ink-100/30 last:border-0"
+      >
+        <code class="text-xs text-blue-600 font-medium leading-relaxed self-start pt-0.5">{{ prop.predicate }}</code>
+        <div class="flex flex-col gap-0.5">
+          <template v-for="(val, vi) in prop.values" :key="vi">
+            <span
+              v-if="prop.nested"
+              class="text-xs text-ink-600 bg-ink-50/60 px-2 py-1 rounded border-l-2 border-ink-200 leading-relaxed break-words"
+            >{{ val }}</span>
+            <span
+              v-else
+              class="text-xs text-ink-600 leading-relaxed break-words"
+            >{{ val }}</span>
+          </template>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>

package/src/components/concept-rdf/RdfPrefixLegend.vue

@@ -0,0 +1,27 @@
+<script setup lang="ts">
+import { computed } from 'vue';
+import { RDF_PREFIXES } from './rdf-prefixes';
+
+const props = defineProps<{
+  collapsed?: boolean;
+}>();
+
+const rows = computed(() => RDF_PREFIXES);
+</script>
+
+<template>
+  <details :open="!collapsed" class="card px-4 py-2 text-[11px]">
+    <summary class="cursor-pointer text-ink-500 select-none hover:text-ink-700">
+      Prefixes <span class="text-ink-300">({{ rows.length }})</span>
+    </summary>
+    <dl class="mt-2 grid grid-cols-[auto_1fr] gap-x-3 gap-y-0.5">
+      <template v-for="p in rows" :key="p.prefix">
+        <dt><code class="text-blue-600">{{ p.prefix }}:</code></dt>
+        <dd>
+          <code class="text-ink-500">{{ p.iri }}</code>
+          <span class="text-ink-300 ml-2">{{ p.description }}</span>
+        </dd>
+      </template>
+    </dl>
+  </details>
+</template>

package/src/components/concept-rdf/RdfSourcePanel.vue

@@ -0,0 +1,72 @@
+<script setup lang="ts">
+import { ref, computed } from 'vue';
+import { RDF_PREFIXES } from './rdf-prefixes';
+
+const props = defineProps<{
+  turtle: string;
+  jsonld: string;
+  resourceCount: number;
+  defaultFormat?: 'turtle' | 'jsonld';
+}>();
+
+const emit = defineEmits<{
+  (e: 'format-change', format: 'turtle' | 'jsonld'): void;
+}>();
+
+const showSource = ref(false);
+const format = ref<'turtle' | 'jsonld'>(props.defaultFormat ?? 'turtle');
+
+const text = computed(() => format.value === 'turtle' ? props.turtle : props.jsonld);
+
+function togglePanel() {
+  showSource.value = !showSource.value;
+}
+
+function pickFormat(next: 'turtle' | 'jsonld') {
+  format.value = next;
+  emit('format-change', next);
+}
+</script>
+
+<template>
+  <div class="card overflow-hidden">
+    <button
+      type="button"
+      class="w-full flex items-center justify-between px-5 py-3.5 text-left hover:bg-ink-50/30 transition-colors"
+      :aria-expanded="showSource"
+      @click="togglePanel"
+    >
+      <div class="flex items-center gap-2">
+        <svg class="w-4 h-4 text-ink-400 transition-transform" :class="showSource ? 'rotate-90' : ''" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5l7 7-7 7"/></svg>
+        <span class="text-sm font-medium text-ink-700">RDF Source</span>
+      </div>
+      <div class="flex items-center gap-2">
+        <select
+          v-model="format"
+          class="text-xs border border-ink-200 rounded px-2 py-1 bg-surface text-ink-600 focus:outline-none focus:ring-1 focus:ring-blue-400"
+          @click.stop
+          @change="pickFormat(format)"
+        >
+          <option value="turtle">Turtle</option>
+          <option value="jsonld">JSON-LD</option>
+        </select>
+        <span class="text-[10px] text-ink-300">{{ resourceCount }} resources</span>
+      </div>
+    </button>
+    <div v-if="showSource" class="border-t border-ink-100/60">
+      <pre
+        dir="auto"
+        class="p-4 text-xs font-mono text-ink-700 bg-ink-50/30 overflow-x-auto leading-relaxed max-h-[600px] overflow-y-auto"
+      >{{ text }}</pre>
+      <details class="border-t border-ink-100/60 px-4 py-2 bg-surface/50">
+        <summary class="text-[11px] text-ink-400 cursor-pointer hover:text-ink-600 select-none">Prefixes ({{ RDF_PREFIXES.length }})</summary>
+        <dl class="mt-2 grid grid-cols-[auto_1fr] gap-x-3 gap-y-0.5 text-[11px]">
+          <template v-for="p in RDF_PREFIXES" :key="p.prefix">
+            <dt><code class="text-blue-600">{{ p.prefix }}:</code></dt>
+            <dd class="text-ink-400">{{ p.iri }}</dd>
+          </template>
+        </dl>
+      </details>
+    </div>
+  </div>
+</template>

package/src/components/concept-rdf/agents-emitter.ts

@@ -0,0 +1,82 @@
+import { FOAF, PROV, DCTERMS, RDFS } from './predicates';
+import { RdfGraph } from './rdf-graph';
+
+export interface AgentInput {
+  readonly slug: string;
+  readonly name: string;
+  readonly role?: string;
+  readonly organization?: string;
+  readonly url?: string;
+  readonly email?: string;
+  readonly agentIri: string;
+}
+
+export interface AgentEmissionResult {
+  readonly graph: RdfGraph;
+  readonly personIris: readonly string[];
+  readonly organizationIris: readonly string[];
+}
+
+function slugify(input: string): string {
+  return input
+    .toLowerCase()
+    .normalize('NFKD')
+    .replace(/[̀-ͯ]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+export function agentsFromContributors(
+  contributors: readonly { name: string; role?: string; organization?: string; url?: string; email?: string }[],
+  agentBase = 'https://glossarist.org/agent',
+): readonly AgentInput[] {
+  return contributors.map(c => ({
+    slug: slugify(c.name),
+    name: c.name,
+    role: c.role,
+    organization: c.organization,
+    url: c.url,
+    email: c.email,
+    agentIri: `${agentBase}/${slugify(c.name)}`,
+  }));
+}
+
+export function emitAgentsGraph(agents: readonly AgentInput[]): AgentEmissionResult {
+  const graph = new RdfGraph();
+  const personIris: string[] = [];
+  const orgSlugs = new Set<string>();
+  const organizationIris: string[] = [];
+
+  for (const a of agents) {
+    const w = graph.declare(a.agentIri, {
+      types: [FOAF.Person, PROV.Person, PROV.Agent],
+      label: a.name,
+      classLabel: 'Person',
+      classId: FOAF.Person,
+    });
+    w.literal(FOAF.name, a.name);
+    if (a.email) w.iri(FOAF.mbox, `mailto:${a.email}`);
+    if (a.url) w.iri(RDFS.seeAlso, a.url);
+    if (a.role) w.literal(DCTERMS.description, a.role);
+    personIris.push(a.agentIri);
+
+    if (a.organization) {
+      const orgSlug = slugify(a.organization);
+      const orgIri = `https://glossarist.org/org/${orgSlug}`;
+      w.iri(PROV.actedOnBehalfOf, orgIri);
+      if (!orgSlugs.has(orgSlug)) {
+        orgSlugs.add(orgSlug);
+        const orgW = graph.declare(orgIri, {
+          types: [FOAF.Organization, PROV.Organization, PROV.Agent],
+          label: a.organization,
+          classLabel: 'Organization',
+          classId: FOAF.Organization,
+        });
+        orgW.literal(FOAF.name, a.organization);
+        organizationIris.push(orgIri);
+      }
+    }
+  }
+
+  return { graph, personIris, organizationIris };
+}

package/src/components/concept-rdf/bibliography-emitter.ts

@@ -0,0 +1,83 @@
+import { DCTERMS, FOAF, RDF } from './predicates';
+import { RdfGraph } from './rdf-graph';
+
+export interface BibliographyEntry {
+  readonly id: string;
+  readonly reference: string;
+  readonly title?: string;
+  readonly link?: string;
+  readonly type?: string;
+}
+
+export interface BibliographyInput {
+  readonly registerId: string;
+  readonly entries: readonly BibliographyEntry[];
+  readonly baseUri?: string;
+}
+
+type BibliographyDataShape =
+  | { [id: string]: BibliographyEntryLike }
+  | { bibliography: readonly BibliographyEntryLike[] };
+
+interface BibliographyEntryLike {
+  readonly id?: string;
+  readonly reference?: string;
+  readonly title?: string;
+  readonly link?: string;
+  readonly type?: string;
+}
+
+export function bibliographyEntryIri(registerId: string, id: string, baseUri = 'https://glossarist.org'): string {
+  return `${baseUri}/${registerId}/bib/${id}`;
+}
+
+export function normalizeBibliographyData(raw: unknown): readonly BibliographyEntry[] {
+  if (!raw || typeof raw !== 'object') return [];
+  const obj = raw as Record<string, unknown>;
+
+  if (Array.isArray(obj.bibliography)) {
+    return (obj.bibliography as readonly BibliographyEntryLike[]).map(e => entryFromV3(e));
+  }
+
+  const entries: BibliographyEntry[] = [];
+  for (const [id, value] of Object.entries(obj)) {
+    if (!value || typeof value !== 'object') continue;
+    const entry = entryFromV3(value as BibliographyEntryLike, id);
+    entries.push(entry);
+  }
+  return entries;
+}
+
+function entryFromV3(e: BibliographyEntryLike, fallbackId?: string): BibliographyEntry {
+  const id = e.id ?? fallbackId ?? '';
+  const reference = e.reference ?? '';
+  return {
+    id,
+    reference,
+    title: e.title,
+    link: e.link,
+    type: e.type,
+  };
+}
+
+export function emitBibliographyGraph(input: BibliographyInput): RdfGraph {
+  const baseUri = input.baseUri ?? 'https://glossarist.org';
+  const graph = new RdfGraph();
+  for (const entry of input.entries) {
+    if (!entry.id || !entry.reference) continue;
+    const iri = bibliographyEntryIri(input.registerId, entry.id, baseUri);
+    const w = graph.declare(iri, {
+      types: ['dcterms:BibliographicResource'],
+      label: entry.title ?? entry.reference,
+      classLabel: 'BibliographicResource',
+      classId: 'dcterms:BibliographicResource',
+    });
+    w.literal(DCTERMS.identifier, entry.id);
+    w.literal(DCTERMS.bibliographicCitation, entry.reference);
+    if (entry.title) w.literal(DCTERMS.title, entry.title);
+    if (entry.link) w.iri(FOAF.page, entry.link);
+    if (entry.type) w.iri(DCTERMS.type, `gloss:bibtype/${entry.type}`);
+    w.iri(DCTERMS.isPartOf, `${baseUri}/${input.registerId}/`);
+  }
+  return graph;
+}

package/src/components/concept-rdf/build-activity-emitter.ts

@@ -0,0 +1,89 @@
+import { GLOSS, DCTERMS, XSD, PROV, FOAF } from './predicates';
+import { RdfGraph, lit, iri, blank, triple } from './rdf-graph';
+
+export interface BuildActivityInput {
+  readonly runId: string;
+  readonly startedAt: string;
+  readonly endedAt: string;
+  readonly gitSha?: string;
+  readonly gitBranch?: string;
+  readonly toolId: string;
+  readonly toolVersion: string;
+  readonly datasetRegisters: readonly string[];
+  readonly conceptCount: number;
+  readonly associatedAgentIri?: string;
+}
+
+export function activityIri(input: BuildActivityInput): string {
+  return `activity/build/${input.runId}`;
+}
+
+export function emitBuildActivityGraph(input: BuildActivityInput): RdfGraph {
+  const graph = new RdfGraph();
+  const iriStr = activityIri(input);
+  const w = graph.declare(iriStr, {
+    types: [PROV.Activity],
+    label: `build ${input.runId}`,
+    classLabel: 'Activity',
+    classId: PROV.Activity,
+  });
+
+  w.literal(PROV.generatedAtTime, input.endedAt, { datatype: XSD.dateTime });
+
+  const startW = graph.declare(`${iriStr}/start`, {
+    types: ['prov:StartingPoint'],
+    label: `start ${input.runId}`,
+    classLabel: 'StartingPoint',
+    classId: 'prov:StartingPoint',
+  });
+  startW.literal('prov:atTime', input.startedAt, { datatype: XSD.dateTime });
+
+  const endW = graph.declare(`${iriStr}/end`, {
+    types: ['prov:EndingPoint'],
+    label: `end ${input.runId}`,
+    classLabel: 'EndingPoint',
+    classId: 'prov:EndingPoint',
+  });
+  endW.literal('prov:atTime', input.endedAt, { datatype: XSD.dateTime });
+
+  if (input.gitSha) {
+    const commitIri = `https://glossarist.org/commit/${input.gitSha}`;
+    w.iri(PROV.used, commitIri);
+    const commitW = graph.declare(commitIri, {
+      types: [PROV.Entity],
+      label: input.gitSha,
+      classLabel: 'Entity',
+      classId: PROV.Entity,
+    });
+    if (input.gitBranch) commitW.literal(DCTERMS.description, `branch: ${input.gitBranch}`);
+  }
+
+  const toolIri = `https://glossarist.org/tool/${input.toolId}/${input.toolVersion}`;
+  w.iri(PROV.used, toolIri);
+  const toolW = graph.declare(toolIri, {
+    types: [PROV.Entity, 'prov:SoftwareAgent'],
+    label: `${input.toolId} ${input.toolVersion}`,
+    classLabel: 'SoftwareAgent',
+    classId: 'prov:SoftwareAgent',
+  });
+  toolW.literal(DCTERMS.identifier, input.toolVersion);
+  toolW.literal('prov:version', input.toolVersion);
+
+  for (const register of input.datasetRegisters) {
+    w.iri(PROV.used, `https://glossarist.org/${register}/`);
+  }
+
+  w.literal('gloss:conceptCount', String(input.conceptCount), { datatype: XSD.integer });
+
+  if (input.associatedAgentIri) {
+    w.iri(PROV.wasAssociatedWith, input.associatedAgentIri);
+    graph.declare(input.associatedAgentIri, {
+      types: [PROV.Agent, FOAF.Person],
+      label: input.associatedAgentIri.split('/').pop() ?? 'agent',
+      classLabel: 'Agent',
+      classId: PROV.Agent,
+    });
+  }
+
+  return graph;
+}