@glossarist/concept-browser 0.7.77 → 0.7.80

package/astro.config.mjs

@@ -20,6 +20,7 @@ export default defineConfig({
   base,
   output: 'static',
   publicDir: resolve(process.cwd(), 'public'),
+  outDir: resolve(process.cwd(), 'dist'),
   integrations: [
     vue({ appEntrypoint: '/src/islands/app-entry' }),
     sitemap(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.77",
+  "version": "0.7.80",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -37,7 +37,7 @@
     "astro": "^7.0.7",
     "d3": "^7.9.0",
     "favicons": "^7.2.0",
-    "glossarist": "^0.4.17",
+    "glossarist": "^0.4.20",
     "js-yaml": "^4.1.0",
     "jszip": "^3.10.1",
     "pinia": "^2.3.1",

package/scripts/bridge-to-astro.mjs

@@ -1,3 +1,8 @@
+function buildConceptUri(uriBase, registerId, conceptId) {
+  return `${uriBase}/${registerId}/concept/${conceptId}`;
+}
+
+
 /**
  * Data bridge: converts public/data/*.json into Astro content collections.
  *
@@ -77,7 +82,7 @@ for (const reg of registry) {
       const conceptEntry = {
         registerId: id,
         conceptId: concept.id,
-        uri: `${entry.uriBase || ''}/${id}/concept/${concept.id}`,
+        uri: buildConceptUri(entry.uriBase || '', id, concept.id),
         status: concept.status || 'valid',
         designations: concept.designations || {},
         eng: concept.eng || concept.designations?.eng || '',

package/scripts/build-edges.js

@@ -1,3 +1,37 @@
+function buildConceptUri(uriBase, registerId, conceptId) {
+  return `${uriBase}/${registerId}/concept/${conceptId}`;
+}
+
+const VALID_COMPLETENESS = new Set(['complete', 'partial']);
+const VALID_CERTAINTY = new Set(['confirmed', 'possible']);
+
+function validateCompleteness(value) {
+  if (value == null) return 'complete';
+  if (!VALID_COMPLETENESS.has(value)) {
+    throw new Error(
+      `Invalid partitive relation completeness: "${value}". Allowed: complete, partial`,
+    );
+  }
+  return value;
+}
+
+function validateCertainty(value) {
+  if (value == null) return 'confirmed';
+  if (!VALID_CERTAINTY.has(value)) {
+    throw new Error(
+      `Invalid partitive member certainty: "${value}". Allowed: confirmed, possible`,
+    );
+  }
+  return value;
+}
+
+function normalizeLocalizedString(content) {
+  if (content == null) return undefined;
+  if (typeof content === 'string') return { default: content };
+  return content;
+}
+
+
 /**
  * Pre-computes cross-reference and domain edges for each dataset.
  * Reads all concept JSON files, extracts structured references and
@@ -108,7 +142,7 @@ function extractRelated(concept, registerId, uriBase, urnMap) {
     const id = ref['gl:id'] || ref['id'];
     if (!source || !id) continue;
     const reg = urnMap.get(source) || source;
-    const target = `${uriBase}/${reg}/concept/${id}`;
+    const target = buildConceptUri(uriBase, reg, id);
     if (target === sourceUri) continue;
     edges.push({
       source: sourceUri,
@@ -121,12 +155,116 @@ function extractRelated(concept, registerId, uriBase, urnMap) {
   return edges;
 }
 
+/**
+ * Extracts partitive relations from a concept's gl:partitiveRelations
+ * array. Returns relation objects (NOT binary GraphEdges) so the UI
+ * can render them with their full set-based semantics: comprehensive +
+ * partitives (each with certainty), completeness, plurality, and
+ * criterion.
+ *
+ * Relations are written to partitive_relations.json, keeping
+ * edges.json binary-only.
+ *
+ * v2 shape per concept-model/TODO.partitive-relation-v2.
+ */
+function extractPartitiveRelations(concept, registerId, uriBase, urnMap) {
+  const relations = [];
+  const sourceUri = concept['@id'];
+  for (const rel of concept['gl:partitiveRelations'] || []) {
+    const compRef = rel['gl:comprehensive'];
+    if (!compRef) continue;
+    const comprehensive = resolveConceptUri(compRef, uriBase, urnMap);
+    if (!comprehensive) continue;
+
+    const partitives = (rel['gl:hasPartitive'] || [])
+      .map(p => {
+        const memberRef = p['gl:ref'] || p;
+        const uri = resolveConceptUri(memberRef, uriBase, urnMap);
+        if (!uri || uri === sourceUri) return null;
+        return {
+          uri,
+          certainty: validateCertainty(p['gl:certainty']),
+        };
+      })
+      .filter(p => p !== null);
+
+    if (partitives.length === 0) continue;
+
+    const plurality = resolvePlurality(rel['gl:hasPlurality']);
+
+    relations.push({
+      source: sourceUri,
+      comprehensive,
+      partitives,
+      completeness: validateCompleteness(rel['gl:completeness']),
+      plurality,
+      criterion: normalizeLocalizedString(rel['gl:criterion']),
+      register: registerId,
+    });
+  }
+  return relations;
+}
+
+function resolvePlurality(plurality) {
+  if (!plurality) return null;
+  const isShared = plurality['gl:isShared'] ?? plurality.is_shared;
+  if (typeof isShared !== 'boolean') return null;
+  const isUncertain = plurality['gl:isUncertain'] ?? plurality.is_uncertain ?? false;
+  const sharedTypeRef = plurality['gl:sharedType'] ?? plurality.shared_type;
+  let sharedType = null;
+  if (sharedTypeRef) {
+    const source = sharedTypeRef['gl:source'] ?? sharedTypeRef.source;
+    const id = sharedTypeRef['gl:id'] ?? sharedTypeRef.id;
+    if (source && id) sharedType = `${source}:${id}`;
+  }
+  return { isShared, isUncertain, sharedType };
+}
+
+function resolveConceptUri(ref, uriBase, urnMap) {
+  const source = ref['gl:source'] || ref['source'];
+  const id = ref['gl:id'] || ref['id'];
+  if (!source || !id) return null;
+  const reg = urnMap.get(source) || source;
+  return buildConceptUri(uriBase, reg, id);
+}
+
 const EXTRACTORS = [extractReferences, extractRelated, extractDomains];
 
 function extractAllEdges(concept, registerId, uriBase, urnMap) {
   return EXTRACTORS.flatMap(fn => fn(concept, registerId, uriBase, urnMap));
 }
 
+/**
+ * Per concept-model TODO.partitive-relation-v2 item 14:
+ * a PartitiveRelation A → {b, c, d} subsumes binary has_part edges
+ * for the same pairs. Warn (don't fail) when both encodings exist.
+ *
+ * Binary edge types considered partitive: has_part, is_part_of,
+ * broader_partitive, narrower_partitive.
+ */
+const BINARY_PARTITIVE_TYPES = new Set(['has_part', 'is_part_of', 'broader_partitive', 'narrower_partitive']);
+
+function warnBinaryPartitiveRedundancy(edges, relations, registerId) {
+  if (!relations?.length) return;
+  const partitivePairs = new Set();
+  for (const rel of relations) {
+    for (const member of rel.partitives ?? []) {
+      const memberUri = member.uri ?? member;
+      partitivePairs.add(`${rel.comprehensive}|${memberUri}`);
+      partitivePairs.add(`${memberUri}|${rel.comprehensive}`);
+    }
+  }
+  const redundant = edges.filter(e =>
+    BINARY_PARTITIVE_TYPES.has(e.type)
+    && partitivePairs.has(`${e.source}|${e.target}`),
+  );
+  if (redundant.length > 0) {
+    console.warn(
+      `  ⚠ ${registerId}: ${redundant.length} binary has_part/is_part_of edge(s) duplicate a PartitiveRelation member — prefer the PartitiveRelation encoding (concept-model TODO item 14).`,
+    );
+  }
+}
+
 // --- Build ---
 
 function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest) {
@@ -140,6 +278,7 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
   console.log(`  Processing ${files.length} concepts...`);
 
   const allEdges = [];
+  const allPartitiveRelations = [];
   const allSourceRefs = [];
   const domainConceptCount = new Map();
   let processed = 0;
@@ -148,7 +287,10 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
     try {
       const data = JSON.parse(readFileSync(join(conceptsDir, file), 'utf-8'));
       const edges = extractAllEdges(data, registerId, uriBase, urnMap);
+      const relations = extractPartitiveRelations(data, registerId, uriBase, urnMap);
+      warnBinaryPartitiveRedundancy(edges, relations, registerId);
       allEdges.push(...edges);
+      allPartitiveRelations.push(...relations);
       allSourceRefs.push(...extractSourceRefs(data, registerId));
 
       for (const edge of edges) {
@@ -186,6 +328,17 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
   writeFileSync(outputPath, JSON.stringify(output));
   console.log(`  Written ${deduped.length} edges to edges.json (${(JSON.stringify(output).length / 1024).toFixed(1)} KB)`);
 
+  // Write partitive_relations.json (parallel to edges.json) for one-to-many
+  // partitive decompositions. See TODO.partitive-relation-v2.
+  const relationsOutput = {
+    registerId,
+    relationCount: allPartitiveRelations.length,
+    relations: allPartitiveRelations,
+  };
+  const relationsPath = join(datasetDir, 'partitive_relations.json');
+  writeFileSync(relationsPath, JSON.stringify(relationsOutput));
+  console.log(`  Written ${allPartitiveRelations.length} partitive relations to partitive_relations.json (${(JSON.stringify(relationsOutput).length / 1024).toFixed(1)} KB)`);
+
   // Build domain-nodes.json from manifest sections (authoritative source)
   const manifestSections = manifest.sections;
   if (manifestSections && manifestSections.length > 0) {

package/scripts/generate-data.mjs

@@ -14,6 +14,11 @@ import { buildVersionHistoryTurtle } from './lib/version-turtle.mjs';
 import { buildBibliographyTurtle } from './lib/bibliography-turtle.mjs';
 import { ttlLit } from './lib/turtle-escape.mjs';
 import { firstNonEmpty } from './lib/first-non-empty.mjs';
+function buildConceptUri(uriBase, registerId, conceptId) {
+  return `${uriBase}/${registerId}/concept/${conceptId}`;
+}
+
+
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
 const ROOT = process.cwd();
 const PUBLIC = path.join(ROOT, 'public');
@@ -60,6 +65,7 @@ function loadConceptFile(filePath) {
 
     // Managed concept-level fields
     if (mc.related) result._related = mc.related;
+    if (mc.partitive_relations) result._partitiveRelations = mc.partitive_relations;
     if (mc.data.domains) result._domains = mc.data.domains;
     if (mc.dates) result._dates = mc.dates;
     if (mc.sources) result._sources = mc.sources;
@@ -98,14 +104,14 @@ async function writeDatasetRdf(register, manifest, concepts, refMaps, opts) {
   const datasetIri = `${uriBase}/${register}/`;
   const topConceptUris = concepts
     .slice(0, 32)
-    .map(c => `${uriBase}/${register}/concept/${c.id}`);
+    .map(c => buildConceptUri(uriBase, register, c.id));
 
   const sections = (manifest.sections ?? []).map(section => {
     const sectionId = section.id ?? section.slug ?? section.title;
     return {
       collectionIri: `${uriBase}/${register}/section/${sectionId}`,
       title: section.title ?? section.name ?? sectionId,
-      memberUris: (section.members ?? []).map(id => `${uriBase}/${register}/concept/${id}`),
+      memberUris: (section.members ?? []).map(id => buildConceptUri(uriBase, register, id)),
     };
   });
 
@@ -242,15 +248,16 @@ function defsToJsonLd(defs) {
     .filter(d => d['gl:content']);
 }
 
-function refToJsonLd(ref) {
+function refToJsonLd(ref, typeName = 'gl:Ref') {
   if (!ref) return undefined;
-  const refObj = { '@type': 'gl:Ref' };
+  const refObj = { '@type': typeName };
   if (typeof ref === 'string') {
     refObj['gl:source'] = ref;
   } else {
     if (ref.source) refObj['gl:source'] = ref.source;
     if (ref.id) refObj['gl:id'] = ref.id;
     if (ref.version) refObj['gl:version'] = ref.version;
+    if (ref.text) refObj['gl:text'] = ref.text;
   }
   return refObj;
 }
@@ -366,12 +373,12 @@ function buildPatternIndex(datasets, registerCache) {
 
 function resolveRefUri(term, refMaps) {
   const resolved = refMaps.patternIndex.resolve(term);
-  if (resolved) return `${refMaps.uriBase}/${resolved.datasetId}/concept/${resolved.conceptId}`;
+  if (resolved) return buildConceptUri(refMaps.uriBase, resolved.datasetId, resolved.conceptId);
 
   const ievMatch = term.match(/^IEV:(\d+[-\d]+)$/);
   if (ievMatch) {
     const dsId = refMaps.refPrefixMap['IEV'];
-    if (dsId) return `${refMaps.uriBase}/${dsId}/concept/${ievMatch[1]}`;
+    if (dsId) return buildConceptUri(refMaps.uriBase, dsId, ievMatch[1]);
   }
   return null;
 }
@@ -405,7 +412,7 @@ function resolveIevRef(display, term, refPrefixMap, uriBase) {
   if (!display.startsWith('IEV:')) return null;
   const datasetId = refPrefixMap['IEV'];
   if (!datasetId) return null;
-  return { id: `${uriBase}/${datasetId}/concept/${display.slice(4)}`, term };
+  return { id: buildConceptUri(uriBase, datasetId, display.slice(4)), term };
 }
 
 /**
@@ -414,7 +421,7 @@ function resolveIevRef(display, term, refPrefixMap, uriBase) {
 function resolvePatternRef(identifier, display, refPrefixMap, patternIndex, uriBase) {
   const r = patternIndex.resolve(identifier);
   if (!r) return null;
-  return { id: `${uriBase}/${r.datasetId}/concept/${r.conceptId}`, term: display };
+  return { id: buildConceptUri(uriBase, r.datasetId, r.conceptId), term: display };
 }
 
 /**
@@ -444,7 +451,7 @@ function handleCiteRef(parsed, allSources) {
 function handleNumeric(parsed, register, uriBase) {
   if (!register) return null;
   const term = parsed.label ?? parsed.id;
-  return { id: `${uriBase}/${register}/concept/${parsed.id}`, term };
+  return { id: buildConceptUri(uriBase, register, parsed.id), term };
 }
 
 /**
@@ -459,7 +466,7 @@ function handleDesignation(parsed, refMaps) {
   const display = parsed.label ?? designation;
   const conceptId = refMaps.designationLookup?.get(designation.toLowerCase());
   return {
-    id: `${refMaps.uriBase}/${register}/concept/${conceptId ?? designation}`,
+    id: buildConceptUri(refMaps.uriBase, register, conceptId ?? designation),
     term: display,
   };
 }
@@ -485,7 +492,7 @@ function handleUnresolved(body, refMaps) {
   // Same-dataset: {{conceptId, displayTerm}} where conceptId is numeric/X.Y
   const register = refMaps.register;
   if (register && (/^\d/.test(identifier) || /^[A-Z]\.\d/.test(identifier))) {
-    return { id: `${refMaps.uriBase}/${register}/concept/${identifier}`, term: display };
+    return { id: buildConceptUri(refMaps.uriBase, register, identifier), term: display };
   }
   return null;
 }
@@ -542,7 +549,7 @@ function extractInlineRefs(localizedData, refMaps, conceptSources = []) {
       const term = parsed.label ?? uri;
       const pattern = refMaps.patternIndex.resolve(uri);
       if (pattern) {
-        ref = { id: `${refMaps.uriBase}/${pattern.datasetId}/concept/${pattern.conceptId}`, term };
+        ref = { id: buildConceptUri(refMaps.uriBase, pattern.datasetId, pattern.conceptId), term };
       } else {
         ref = { id: uri, term };
       }
@@ -571,7 +578,7 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
   const base = refMaps.uriBase;
   const doc = {
     '@context': 'https://glossarist.org/ns/context.jsonld',
-    '@id': `${base}/${register}/concept/${termid}`,
+    '@id': buildConceptUri(base, register, termid),
     '@type': 'gl:Concept',
     'gl:identifier': termid,
   };
@@ -672,6 +679,50 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
     });
   }
 
+  if (conceptYaml._partitiveRelations?.length > 0) {
+    doc['gl:partitiveRelations'] = conceptYaml._partitiveRelations.map(rel => {
+      const out = { '@type': 'gl:PartitiveRelation' };
+      if (rel.comprehensive) {
+        out['gl:comprehensive'] = refToJsonLd(rel.comprehensive, 'gl:ConceptRef');
+      }
+      if (Array.isArray(rel.partitives) && rel.partitives.length > 0) {
+        out['gl:hasPartitive'] = rel.partitives.map(member => {
+          const m = { '@type': 'gl:PartitiveMember' };
+          if (member.ref) {
+            m['gl:ref'] = refToJsonLd(member.ref, 'gl:ConceptRef');
+          } else {
+            m['gl:ref'] = refToJsonLd(member, 'gl:ConceptRef');
+          }
+          if (member.certainty) m['gl:certainty'] = member.certainty;
+          return m;
+        });
+      }
+      if (rel.completeness) {
+        out['gl:completeness'] = rel.completeness;
+      }
+      if (rel.plurality) {
+        const pl = { '@type': 'gl:TypeSharedPlurality' };
+        pl['gl:isShared'] = rel.plurality.is_shared ?? rel.plurality.isShared ?? false;
+        if (rel.plurality.is_uncertain ?? rel.plurality.isUncertain) {
+          pl['gl:isUncertain'] = rel.plurality.is_uncertain ?? rel.plurality.isUncertain;
+        }
+        if (rel.plurality.shared_type ?? rel.plurality.sharedType) {
+          pl['gl:sharedType'] = refToJsonLd(
+            rel.plurality.shared_type ?? rel.plurality.sharedType,
+            'gl:ConceptRef',
+          );
+        }
+        out['gl:hasPlurality'] = pl;
+      }
+      if (rel.criterion) {
+        out['gl:criterion'] = typeof rel.criterion === 'string'
+          ? { default: rel.criterion }
+          : rel.criterion;
+      }
+      return out;
+    });
+  }
+
   return doc;
 }
 
@@ -920,8 +971,74 @@ async function processDataset(dir, register, opts) {
 
   const dsRefMaps = { ...refMaps, register, designationLookup };
 
-  const sourceMap = new Map();
-  const relTypeCounts = {};
+  const stats = {
+    sourceMap: new Map(),
+    relTypeCounts: {},
+    partitiveRelations: {
+      count: 0,
+      byCompleteness: { complete: 0, partial: 0 },
+      byMemberCertainty: { confirmed: 0, possible: 0 },
+      withCriterion: 0,
+      withoutCriterion: 0,
+      withPlurality: 0,
+    },
+  };
+
+  const STATS_PROCESSORS = [
+    function collectSources(cy, termid, s) {
+      const refs = new Set();
+      const allSources = [
+        ...(cy._sources || []),
+        ...opts.languages.flatMap(l => cy[l]?.sources || []),
+      ];
+      for (const src of allSources) {
+        const ref = src.origin?.ref?.source || src.origin?.ref?.id || 'Unknown';
+        refs.add(ref);
+        if (!s.sourceMap.has(ref)) s.sourceMap.set(ref, { ref, types: new Set(), conceptIds: [] });
+        if (src.type) s.sourceMap.get(ref).types.add(src.type);
+      }
+      for (const ref of refs) s.sourceMap.get(ref)?.conceptIds.push(termid);
+    },
+    function countRelationships(cy, _termid, s) {
+      for (const r of cy._related || []) {
+        const type = r.type || 'unknown';
+        s.relTypeCounts[type] = (s.relTypeCounts[type] || 0) + 1;
+      }
+    },
+    function countPartitiveRelations(cy, _termid, s) {
+      for (const rel of cy._partitiveRelations || []) {
+        s.partitiveRelations.count += 1;
+        const completeness = rel.completeness || 'complete';
+        s.partitiveRelations.byCompleteness[completeness] =
+          (s.partitiveRelations.byCompleteness[completeness] || 0) + 1;
+        const partitives = rel.partitives || [];
+        for (const member of partitives) {
+          const certainty = member.certainty || 'confirmed';
+          s.partitiveRelations.byMemberCertainty[certainty] =
+            (s.partitiveRelations.byMemberCertainty[certainty] || 0) + 1;
+        }
+        if (rel.criterion) {
+          s.partitiveRelations.withCriterion += 1;
+        } else {
+          s.partitiveRelations.withoutCriterion += 1;
+        }
+        if (rel.plurality) {
+          s.partitiveRelations.withPlurality += 1;
+        }
+      }
+    },
+    function countLanguages(cy, _termid, _s) {
+      for (const lang of opts.languages) {
+        const lc = cy[lang];
+        if (lc) {
+          if (lc.terms?.length > 0) langTermCounts[lang] = (langTermCounts[lang] || 0) + 1;
+          if (lc.definition && (Array.isArray(lc.definition) ? lc.definition.some(d => d.content) : lc.definition)) {
+            langDefCounts[lang] = (langDefCounts[lang] || 0) + 1;
+          }
+        }
+      }
+    },
+  ];
 
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
@@ -933,21 +1050,17 @@ async function processDataset(dir, register, opts) {
       const jsonld = yamlToJsonLd(conceptYaml, register, dsRefMaps);
       writeJson(path.join(conceptsDir, `${termid}.json`), jsonld);
 
-      // Generate Turtle format
       const ttlContent = conceptJsonToTurtle(jsonld);
       fs.writeFileSync(path.join(conceptsDir, `${termid}.ttl`), ttlContent);
 
-      // Generate SKOS JSON-LD format
       const skosJsonLd = conceptJsonToSkosJsonLd(jsonld);
       fs.writeFileSync(path.join(conceptsDir, `${termid}.jsonld`), skosJsonLd);
 
-      // Generate TBX-XML format
       const tbxContent = conceptJsonToTbx(jsonld);
       if (tbxContent) {
         fs.writeFileSync(path.join(conceptsDir, `${termid}.tbx`), tbxContent);
       }
 
-      // Copy source YAML
       fs.copyFileSync(path.join(dir, file), path.join(conceptsDir, `${termid}.yaml`));
 
       concepts.push({
@@ -957,38 +1070,8 @@ async function processDataset(dir, register, opts) {
         status: conceptYaml.eng?.entry_status || 'valid',
       });
 
-      const conceptSourceRefs = new Set();
-      const allSourceArrays = [
-        ...(conceptYaml._sources || []),
-        ...opts.languages.flatMap(l => conceptYaml[l]?.sources || []),
-      ];
-      for (const src of allSourceArrays) {
-        const ref = src.origin?.ref?.source || src.origin?.ref?.id || 'Unknown';
-        conceptSourceRefs.add(ref);
-        if (!sourceMap.has(ref)) {
-          sourceMap.set(ref, { ref, types: new Set(), conceptIds: [] });
-        }
-        if (src.type) sourceMap.get(ref).types.add(src.type);
-      }
-      for (const ref of conceptSourceRefs) {
-        sourceMap.get(ref)?.conceptIds.push(termid);
-      }
-
-      for (const r of conceptYaml._related || []) {
-        const type = r.type || 'unknown';
-        relTypeCounts[type] = (relTypeCounts[type] || 0) + 1;
-      }
-
-      for (const lang of opts.languages) {
-        const lc = conceptYaml[lang];
-        if (lc) {
-          if (lc.terms && lc.terms.length > 0) {
-            langTermCounts[lang] = (langTermCounts[lang] || 0) + 1;
-          }
-          if (lc.definition && (Array.isArray(lc.definition) ? lc.definition.some(d => d.content) : lc.definition)) {
-            langDefCounts[lang] = (langDefCounts[lang] || 0) + 1;
-          }
-        }
+      for (const processor of STATS_PROCESSORS) {
+        processor(conceptYaml, termid, stats);
       }
     } catch (e) {
       console.warn(`  Skipping ${file}: ${e.message}`);
@@ -1097,7 +1180,7 @@ async function processDataset(dir, register, opts) {
     }
   }
 
-  const sourceStats = Array.from(sourceMap.values())
+  const sourceStats = Array.from(stats.sourceMap.values())
     .map(s => ({
       ref: s.ref,
       types: Array.from(s.types),
@@ -1105,13 +1188,14 @@ async function processDataset(dir, register, opts) {
       conceptIds: s.conceptIds,
     }))
     .sort((a, b) => b.conceptCount - a.conceptCount);
-  const totalRelationships = Object.values(relTypeCounts).reduce((a, b) => a + b, 0);
+  const totalRelationships = Object.values(stats.relTypeCounts).reduce((a, b) => a + b, 0);
 
   writeJson(path.join(DATA, register, 'stats.json'), {
     sourceCount: sourceStats.length,
     sources: sourceStats,
     relationshipCount: totalRelationships,
-    relationshipTypes: relTypeCounts,
+    relationshipTypes: stats.relTypeCounts,
+    partitiveRelations: stats.partitiveRelations,
   });
 
   const manifest = {