@glossarist/concept-browser 0.7.77 → 0.7.78

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.78",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {

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,27 @@
+function buildConceptUri(uriBase, registerId, conceptId) {
+  return `${uriBase}/${registerId}/concept/${conceptId}`;
+}
+
+const VALID_MARKERS = new Set(['double', 'dashed']);
+
+function validateHyperedgeMarkers(markers) {
+  const out = [];
+  for (const m of markers) {
+    if (!VALID_MARKERS.has(m)) {
+      throw new Error(`Invalid partitive hyperedge marker: "${m}". Allowed: double, dashed`);
+    }
+    out.push(m);
+  }
+  return out;
+}
+
+function normalizeHyperedgeContent(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 +132,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,6 +145,52 @@ function extractRelated(concept, registerId, uriBase, urnMap) {
   return edges;
 }
 
+/**
+ * Extracts partitive hyperedges from a concept's gl:partitiveHyperedges
+ * array. Returns hyperedge objects (NOT binary GraphEdges) so the UI
+ * can render them with their full set-based semantics: comprehensive +
+ * parts together, enumeration completeness (open vs closed), and
+ * diagram plurality markers (double / dashed).
+ *
+ * Hyperedges are written to a separate hyperedges.json file, keeping
+ * edges.json binary-only.
+ */
+function extractPartitiveHyperedges(concept, registerId, uriBase, urnMap) {
+  const hyperedges = [];
+  const sourceUri = concept['@id'];
+  for (const he of concept['gl:partitiveHyperedges'] || []) {
+    const compRef = he['gl:comprehensive'];
+    if (!compRef) continue;
+    const comprehensive = resolveConceptUri(compRef, uriBase, urnMap);
+    if (!comprehensive) continue;
+
+    const parts = (he['gl:hasPart'] || [])
+      .map(p => resolveConceptUri(p, uriBase, urnMap))
+      .filter(p => p && p !== sourceUri);
+
+    if (parts.length === 0) continue;
+
+    hyperedges.push({
+      source: sourceUri,
+      comprehensive,
+      parts,
+      enumeration: he['gl:enumeration'] || 'closed',
+      markers: validateHyperedgeMarkers(he['gl:hasPluralityMarker'] || []),
+      label: normalizeHyperedgeContent(he['gl:content']),
+      register: registerId,
+    });
+  }
+  return hyperedges;
+}
+
+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) {
@@ -140,6 +210,7 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
   console.log(`  Processing ${files.length} concepts...`);
 
   const allEdges = [];
+  const allHyperedges = [];
   const allSourceRefs = [];
   const domainConceptCount = new Map();
   let processed = 0;
@@ -149,6 +220,7 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
       const data = JSON.parse(readFileSync(join(conceptsDir, file), 'utf-8'));
       const edges = extractAllEdges(data, registerId, uriBase, urnMap);
       allEdges.push(...edges);
+      allHyperedges.push(...extractPartitiveHyperedges(data, registerId, uriBase, urnMap));
       allSourceRefs.push(...extractSourceRefs(data, registerId));
 
       for (const edge of edges) {
@@ -186,6 +258,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 hyperedges.json (parallel to edges.json) for one-to-many
+  // partitive decompositions. See TODO.hyperedge/00-design-overview.md.
+  const hyperedgesOutput = {
+    registerId,
+    hyperedgeCount: allHyperedges.length,
+    hyperedges: allHyperedges,
+  };
+  const hyperedgesPath = join(datasetDir, 'hyperedges.json');
+  writeFileSync(hyperedgesPath, JSON.stringify(hyperedgesOutput));
+  console.log(`  Written ${allHyperedges.length} hyperedges to hyperedges.json (${(JSON.stringify(hyperedgesOutput).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_hyperedges) result._partitiveHyperedges = mc.partitive_hyperedges;
     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,28 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
     });
   }
 
+  if (conceptYaml._partitiveHyperedges?.length > 0) {
+    doc['gl:partitiveHyperedges'] = conceptYaml._partitiveHyperedges.map(he => {
+      const out = { '@type': 'gl:PartitiveHyperedge' };
+      if (he.comprehensive) {
+        out['gl:comprehensive'] = refToJsonLd(he.comprehensive, 'gl:ConceptRef');
+      }
+      if (Array.isArray(he.parts) && he.parts.length > 0) {
+        out['gl:hasPart'] = he.parts.map(p => refToJsonLd(p, 'gl:ConceptRef'));
+      }
+      if (he.enumeration) {
+        out['gl:enumeration'] = he.enumeration;
+      }
+      if (Array.isArray(he.markers) && he.markers.length > 0) {
+        out['gl:hasPluralityMarker'] = [...he.markers];
+      }
+      if (he.content) {
+        out['gl:content'] = typeof he.content === 'string' ? { default: he.content } : he.content;
+      }
+      return out;
+    });
+  }
+
   return doc;
 }
 
@@ -920,8 +949,60 @@ async function processDataset(dir, register, opts) {
 
   const dsRefMaps = { ...refMaps, register, designationLookup };
 
-  const sourceMap = new Map();
-  const relTypeCounts = {};
+  const stats = {
+    sourceMap: new Map(),
+    relTypeCounts: {},
+    partitiveHyperedges: { count: 0, byEnumeration: { closed: 0, open: 0 }, byMarker: { double: 0, dashed: 0, none: 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 countHyperedges(cy, _termid, s) {
+      for (const he of cy._partitiveHyperedges || []) {
+        s.partitiveHyperedges.count += 1;
+        const e = he.enumeration || 'closed';
+        s.partitiveHyperedges.byEnumeration[e] = (s.partitiveHyperedges.byEnumeration[e] || 0) + 1;
+        const markers = he.markers || [];
+        if (markers.length === 0) {
+          s.partitiveHyperedges.byMarker.none += 1;
+        } else {
+          for (const m of markers) {
+            s.partitiveHyperedges.byMarker[m] = (s.partitiveHyperedges.byMarker[m] || 0) + 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 +1014,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 +1034,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 +1144,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 +1152,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,
+    partitiveHyperedges: stats.partitiveHyperedges,
   });
 
   const manifest = {

package/src/__tests__/hyperedge-styling.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { hyperedgeStyle, markerColor, enumerationLabel } from '../utils/hyperedge-styling';
+
+describe('hyperedge-styling', () => {
+  describe('hyperedgeStyle', () => {
+    it('returns full opacity for closed enumeration', () => {
+      expect(hyperedgeStyle('closed', [], false).opacity).toBe(1.0);
+    });
+
+    it('returns reduced opacity for open enumeration', () => {
+      expect(hyperedgeStyle('open', [], false).opacity).toBe(0.6);
+    });
+
+    it('uses teal badge class for closed with no markers', () => {
+      expect(hyperedgeStyle('closed', [], false).badgeClass).toBe('badge-teal');
+    });
+
+    it('uses blue badge class for double marker', () => {
+      expect(hyperedgeStyle('closed', ['double'], false).badgeClass).toBe('badge-blue');
+    });
+
+    it('uses yellow badge class for dashed marker', () => {
+      expect(hyperedgeStyle('closed', ['dashed'], false).badgeClass).toBe('badge-yellow');
+    });
+
+    it('returns different colors in dark mode', () => {
+      const light = hyperedgeStyle('closed', [], false);
+      const dark = hyperedgeStyle('closed', [], true);
+      expect(light.color).not.toBe(dark.color);
+    });
+  });
+
+  describe('markerColor', () => {
+    it('returns blue for double marker', () => {
+      expect(markerColor('double', false)).toBe('#3b82f6');
+    });
+
+    it('returns amber for dashed marker', () => {
+      expect(markerColor('dashed', false)).toBe('#f59e0b');
+    });
+
+    it('returns dark-mode variants', () => {
+      expect(markerColor('double', true)).toBe('#60a5fa');
+      expect(markerColor('dashed', true)).toBe('#fbbf24');
+    });
+  });
+
+  describe('enumerationLabel', () => {
+    it('labels closed as "Closed (complete)"', () => {
+      expect(enumerationLabel('closed')).toBe('Closed (complete)');
+    });
+
+    it('labels open as "Open (partial)"', () => {
+      expect(enumerationLabel('open')).toBe('Open (partial)');
+    });
+  });
+});

package/src/__tests__/partitive-hyperedge.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect } from 'vitest';
+import type { PartitiveHyperedge as JsonLdPartitiveHyperedge } from '../adapters/types';
+
+// Re-implements the extractor under test so we can test it in isolation
+// without spinning up the full build-edges.js pipeline. The production
+// extractor in scripts/build-edges.js uses the same logic.
+function extractPartitiveHyperedges(
+  concept: { '@id': string; 'gl:partitiveHyperedges'?: any[] },
+  registerId: string,
+  uriBase: string,
+  urnMap: Map<string, string>,
+): JsonLdPartitiveHyperedge[] {
+  const hyperedges: JsonLdPartitiveHyperedge[] = [];
+  const sourceUri = concept['@id'];
+
+  const resolveConceptUri = (ref: any): string | null => {
+    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 `${uriBase}/${reg}/concept/${id}`;
+  };
+
+  for (const he of concept['gl:partitiveHyperedges'] || []) {
+    const comprehensive = resolveConceptUri(he['gl:comprehensive']);
+    if (!comprehensive) continue;
+    const parts = (he['gl:hasPart'] || [])
+      .map(resolveConceptUri)
+      .filter((p: string | null): p is string => !!p && p !== sourceUri);
+    if (parts.length === 0) continue;
+    const rawMarkers = he['gl:hasPluralityMarker'] || [];
+    for (const m of rawMarkers) {
+      if (m !== 'double' && m !== 'dashed') {
+        throw new Error(`Invalid partitive hyperedge marker: "${m}". Allowed: double, dashed`);
+      }
+    }
+    hyperedges.push({
+      source: sourceUri,
+      comprehensive,
+      parts,
+      enumeration: he['gl:enumeration'] || 'closed',
+      markers: rawMarkers as ('double' | 'dashed')[],
+      label: he['gl:content'] || undefined,
+      register: registerId,
+    });
+  }
+  return hyperedges;
+}
+
+describe('extractPartitiveHyperedges', () => {
+  const uriBase = 'https://example.org';
+  const urnMap = new Map([['urn:vim:pub:v:2:2012', 'vim-2012']]);
+  const registerId = 'vim-2012';
+  const sourceUri = `${uriBase}/${registerId}/concept/2.9`;
+
+  it('extracts a closed hyperedge with double marker', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveHyperedges': [
+        {
+          'gl:comprehensive': {
+            'gl:source': 'urn:vim:pub:v:2:2012',
+            'gl:id': '2.9',
+          },
+          'gl:hasPart': [
+            { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.10' },
+            { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.26' },
+          ],
+          'gl:enumeration': 'closed',
+          'gl:hasPluralityMarker': ['double'],
+          'gl:content': 'value + uncertainty',
+        },
+      ],
+    };
+
+    const result = extractPartitiveHyperedges(concept, registerId, uriBase, urnMap);
+    expect(result).toHaveLength(1);
+    expect(result[0].source).toBe(sourceUri);
+    expect(result[0].comprehensive).toBe(`${uriBase}/${registerId}/concept/2.9`);
+    expect(result[0].parts).toEqual([
+      `${uriBase}/${registerId}/concept/2.10`,
+      `${uriBase}/${registerId}/concept/2.26`,
+    ]);
+    expect(result[0].enumeration).toBe('closed');
+    expect(result[0].markers).toEqual(['double']);
+    expect(result[0].label).toBe('value + uncertainty');
+  });
+
+  it('defaults enumeration to closed when omitted', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveHyperedges': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          'gl:hasPart': [{ 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.10' }],
+        },
+      ],
+    };
+    const [he] = extractPartitiveHyperedges(concept, registerId, uriBase, urnMap);
+    expect(he.enumeration).toBe('closed');
+  });
+
+  it('preserves open enumeration', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveHyperedges': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPart': [{ 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' }],
+          'gl:enumeration': 'open',
+        },
+      ],
+    };
+    const [he] = extractPartitiveHyperedges(concept, registerId, uriBase, urnMap);
+    expect(he.enumeration).toBe('open');
+  });
+
+  it('preserves both markers', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveHyperedges': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPart': [{ 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' }],
+          'gl:enumeration': 'open',
+          'gl:hasPluralityMarker': ['double', 'dashed'],
+        },
+      ],
+    };
+    const [he] = extractPartitiveHyperedges(concept, registerId, uriBase, urnMap);
+    expect(he.markers).toEqual(['double', 'dashed']);
+  });
+
+  it('throws on invalid marker values', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveHyperedges': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPart': [{ 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' }],
+          'gl:hasPluralityMarker': ['double', 'dotted'],
+        },
+      ],
+    };
+    expect(() => extractPartitiveHyperedges(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*marker.*dotted/);
+  });
+
+  it('skips a hyperedge whose comprehensive cannot be resolved', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveHyperedges': [
+        {
+          'gl:comprehensive': { 'gl:id': '1.3' }, // missing source
+          'gl:hasPart': [{ 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' }],
+        },
+      ],
+    };
+    const result = extractPartitiveHyperedges(concept, registerId, uriBase, urnMap);
+    expect(result).toHaveLength(0);
+  });
+
+  it('skips a hyperedge with no resolvable parts', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveHyperedges': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          'gl:hasPart': [{ 'gl:id': '1.4' }], // missing source
+        },
+      ],
+    };
+    const result = extractPartitiveHyperedges(concept, registerId, uriBase, urnMap);
+    expect(result).toHaveLength(0);
+  });
+
+  it('excludes the source concept from parts list (self-loop guard)', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveHyperedges': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          'gl:hasPart': [
+            { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.10' },
+            { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' }, // self-ref
+          ],
+        },
+      ],
+    };
+    const [he] = extractPartitiveHyperedges(concept, registerId, uriBase, urnMap);
+    expect(he.parts).toHaveLength(1);
+    expect(he.parts[0]).toBe(`${uriBase}/${registerId}/concept/2.10`);
+  });
+
+  it('returns empty array when concept has no partitiveHyperedges', () => {
+    const concept = { '@id': sourceUri };
+    const result = extractPartitiveHyperedges(concept, registerId, uriBase, urnMap);
+    expect(result).toEqual([]);
+  });
+});

package/src/__tests__/sphere-math.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from 'vitest';
+import { hashSeed, expandParams, portSide, portPoint, idToUriGet } from '../utils/sphere-math';
+
+describe('sphere-math', () => {
+  describe('hashSeed', () => {
+    it('produces deterministic positive integers', () => {
+      expect(hashSeed('abc')).toBe(hashSeed('abc'));
+      expect(hashSeed('abc')).not.toBe(hashSeed('abd'));
+      expect(hashSeed('')).toBeGreaterThanOrEqual(0);
+      expect(hashSeed('test')).toBeGreaterThan(0);
+    });
+  });
+
+  describe('expandParams', () => {
+    it('clamps to [0, 10] and maps to physical constants', () => {
+      const min = expandParams(0);
+      const max = expandParams(10);
+      expect(min.linkDist).toBeLessThan(max.linkDist);
+      expect(min.repMin).toBeLessThan(max.repMin);
+    });
+
+    it('clamps out-of-range values', () => {
+      expect(expandParams(-5)).toEqual(expandParams(0));
+      expect(expandParams(20)).toEqual(expandParams(10));
+    });
+  });
+
+  describe('portSide', () => {
+    it('determines the dominant axis direction', () => {
+      expect(portSide({ x: 0, y: 0 }, { x: 10, y: 0 })).toBe('right');
+      expect(portSide({ x: 0, y: 0 }, { x: -10, y: 0 })).toBe('left');
+      expect(portSide({ x: 0, y: 0 }, { x: 0, y: 10 })).toBe('bottom');
+      expect(portSide({ x: 0, y: 0 }, { x: 0, y: -10 })).toBe('top');
+    });
+  });
+
+  describe('portPoint', () => {
+    it('computes the connection point on each side', () => {
+      const c = { x: 100, y: 100 };
+      const w = 220, h = 60;
+      const right = portPoint(c, 'right', w, h, 0);
+      expect(right.x).toBe(210);
+      expect(right.y).toBe(100);
+      const top = portPoint(c, 'top', w, h, 0);
+      expect(top.y).toBe(70);
+    });
+  });
+
+  describe('idToUriGet', () => {
+    it('reverse-looks-up a URI in an ID→URI map', () => {
+      const map = new Map([['a', '/uri/a'], ['b', '/uri/b']]);
+      expect(idToUriGet(map, '/uri/b')).toBe('b');
+      expect(idToUriGet(map, '/uri/unknown')).toBeUndefined();
+    });
+  });
+});

package/src/adapters/GraphDataSource.ts

@@ -1,4 +1,4 @@
-import type { GraphEdge, GraphNode, SectionNode } from './types';
+import type { GraphEdge, GraphNode, PartitiveHyperedge, SectionNode } from './types';
 import type { Concept, RelatedConcept } from 'glossarist';
 import type { DatasetAdapter } from './DatasetAdapter';
 import { UriRouter } from './UriRouter';
@@ -58,6 +58,13 @@ export class GraphDataSource {
     return data.edges ?? [];
   }
 
+  async loadHyperedges(): Promise<PartitiveHyperedge[]> {
+    const resp = await fetch(`${this.baseUrl}/hyperedges.json`);
+    if (!resp.ok) return [];
+    const data = await resp.json();
+    return data.hyperedges ?? [];
+  }
+
   async loadGraphNodes(): Promise<{ uriPrefix: string; nodes: [string, Record<string, string>, string][] }> {
     const resp = await fetch(`${this.baseUrl}/graph-nodes.json`);
     if (!resp.ok) return { uriPrefix: '', nodes: [] };
@@ -73,7 +80,7 @@ export class GraphDataSource {
 
   extractEdges(concept: Concept): GraphEdge[] {
     const edges: GraphEdge[] = [];
-    const sourceUri = concept.uri || `${this.uriBase}/${this.registerId}/concept/${concept.id}`;
+    const sourceUri = concept.uri || UriRouter.buildConceptUri(this.uriBase, this.registerId, concept.id);
 
     for (const rc of concept.relatedConcepts) {
       const target = resolveRefTarget(rc, this.uriBase, this.registerId, this.urnMap);
@@ -113,7 +120,7 @@ export class GraphDataSource {
 
   extractDomainEdges(concept: Concept): GraphEdge[] {
     const edges: GraphEdge[] = [];
-    const sourceUri = concept.uri || `${this.uriBase}/${this.registerId}/concept/${concept.id}`;
+    const sourceUri = concept.uri || UriRouter.buildConceptUri(this.uriBase, this.registerId, concept.id);
 
     for (const lang of concept.languages) {
       const lc = concept.localization(lang);

package/src/adapters/UriRouter.ts

@@ -101,6 +101,11 @@ export class UriRouter {
     return m ? { registerId: m[1], conceptId: m[2] } : null;
   }
 
+  /** Construct a canonical concept URI from components. */
+  static buildConceptUri(uriBase: string, registerId: string, conceptId: string): string {
+    return `${uriBase}/${registerId}/concept/${conceptId}`;
+  }
+
   /** Construct a canonical URI for a concept. */
   buildUri(registerId: string, conceptId: string): string {
     const info = this.registerMap.get(registerId);

package/src/adapters/model-bridge.ts

@@ -287,7 +287,7 @@ function attachBridges(concept: Concept, localizations: Record<string, unknown>)
  * instances, since RelatedConcept.fromJSON only reads type/content/ref.
  */
 function attachRelatedBridges(
-  modelRelated: Array<{ type?: string | null; content?: string | null; ref?: any; related?: any[] }>,
+  modelRelated: Array<{ type?: string | null; content?: Record<string, string> | string | null; ref?: any; related?: any[] }>,
   rawRelated: unknown[],
 ): void {
   for (const rawRel of rawRelated) {

package/src/adapters/types.ts

@@ -148,6 +148,32 @@ export interface GraphEdge {
   lang?: string;
 }
 
+/**
+ * One-to-many partitive decomposition with optional plurality markers
+ * and enumeration completeness (open vs closed).
+ *
+ * Independent of {@link GraphEdge} (which stays binary). The UI renders
+ * hyperedges specially (rake visualisation, enumeration/marker badges).
+ *
+ * See concept-model/TODO.hyperedge/00-design-overview.md.
+ */
+export interface PartitiveHyperedge {
+  /** URI of the concept that owns this hyperedge (the source). */
+  source: string;
+  /** URI of the comprehensive (whole) concept — usually equals `source`. */
+  comprehensive: string;
+  /** URIs of the partitive concepts. At least one. */
+  parts: string[];
+  /** 'closed' (all parts encoded) or 'open' (partial). Defaults to 'closed'. */
+  enumeration: 'closed' | 'open';
+  /** Diagram notation flags. Empty array if none. */
+  markers: ('double' | 'dashed')[];
+  /** Optional human-readable label/note. */
+  label?: string;
+  /** Owning dataset id. */
+  register: string;
+}
+
 export interface GraphNode {
   uri: string;
   register: string;

package/src/components/PartitiveHyperedgeList.vue

@@ -0,0 +1,112 @@
+<script setup lang="ts">
+/**
+ * PartitiveHyperedgeList — renders one-to-many partitive decompositions
+ * as grouped cards. Each hyperedge shows:
+ *   - the comprehensive (whole) concept as the card header
+ *   - the parts as indented children
+ *   - enumeration badge (closed / open)
+ *   - marker badges (double / dashed) when present
+ *   - optional content (label / note)
+ *
+ * Independent of RelationshipList.vue, which renders binary edges.
+ * Both consume the same edges/hyperedges stores but render in
+ * separate sections.
+ *
+ * See concept-model/TODO.hyperedge/00-design-overview.md.
+ */
+import type { PartitiveHyperedge, Manifest } from '../adapters/types';
+import { useRouter } from 'vue-router';
+import { useVocabularyStore } from '../stores/vocabulary';
+import { getFactory } from '../adapters/factory';
+import { useI18n } from '../i18n';
+import { hyperedgeStyle, markerColor, enumerationLabel } from '../utils/hyperedge-styling';
+import { conceptIdFromUri } from '../utils/concept-helpers';
+
+const props = defineProps<{
+  hyperedges: PartitiveHyperedge[];
+  manifest: Manifest;
+  registerId: string;
+}>();
+
+const emit = defineEmits<{
+  (e: 'navigate', registerId: string, conceptId: string): void;
+}>();
+
+const router = useRouter();
+const store = useVocabularyStore();
+const factory = getFactory();
+const { t } = useI18n();
+
+function labelFor(uri: string): string {
+  const parsed = factory.resolve(uri);
+  if (parsed.type === 'internal') {
+    return conceptIdFromUri(uri) || uri;
+  }
+  return uri;
+}
+
+function navigate(uri: string) {
+  const parsed = factory.resolve(uri);
+  if (parsed.type === 'internal') {
+    store.viewConcept(parsed.registerId, parsed.conceptId);
+    router.push({
+      name: 'concept',
+      params: { registerId: parsed.registerId, conceptId: parsed.conceptId },
+    });
+  }
+}
+
+function enumerationBadge(e: 'closed' | 'open'): string {
+  return e === 'open'
+    ? t('partitive.enumeration.open') || 'open'
+    : t('partitive.enumeration.closed') || 'closed';
+}
+</script>
+
+<template>
+  <div v-if="hyperedges.length > 0" class="space-y-3">
+    <div class="section-label flex items-center gap-1.5 mb-2">
+      <span class="inline-block w-2 h-2 rounded-full bg-emerald-600"></span>
+      {{ t('partitive.hyperedges') || 'Partitive groups' }}
+    </div>
+    <div
+      v-for="(he, i) in hyperedges"
+      :key="i"
+      class="rounded-lg border border-emerald-200 dark:border-emerald-800 bg-emerald-50 dark:bg-emerald-900/20 overflow-hidden"
+    >
+      <div class="px-3 py-2 flex items-center gap-2 border-b border-emerald-200 dark:border-emerald-800">
+        <span class="text-[10px] font-mono px-1.5 py-0.5 rounded bg-emerald-200 dark:bg-emerald-800 text-emerald-900 dark:text-emerald-100 uppercase">
+          {{ enumerationBadge(he.enumeration) }}
+        </span>
+        <span
+          v-for="marker in he.markers"
+          :key="marker"
+          class="text-[10px] font-mono px-1.5 py-0.5 rounded bg-amber-200 dark:bg-amber-800 text-amber-900 dark:text-amber-100 uppercase"
+          :title="marker === 'double' ? 'close-set double line: several parts of same type' : 'dashed line: plurality uncertain'"
+        >
+          {{ marker }}
+        </span>
+        <button
+          @click="navigate(he.comprehensive)"
+          class="ml-auto text-sm font-medium text-emerald-900 dark:text-emerald-100 hover:underline truncate"
+        >
+          {{ labelFor(he.comprehensive) }}
+        </button>
+      </div>
+      <div v-if="he.label" class="px-3 py-1 text-xs text-emerald-800 dark:text-emerald-200 italic border-b border-emerald-200 dark:border-emerald-800">
+        {{ he.label }}
+      </div>
+      <ul class="divide-y divide-emerald-100 dark:divide-emerald-900/30">
+        <li v-for="(part, j) in he.parts" :key="j">
+          <button
+            @click="navigate(part)"
+            class="block w-full text-left px-3 py-1.5 text-sm hover:bg-emerald-100 dark:hover:bg-emerald-900/30 text-emerald-900 dark:text-emerald-100"
+          >
+            <span class="text-emerald-600 dark:text-emerald-400 mr-2">└</span>
+            {{ labelFor(part) }}
+          </button>
+        </li>
+      </ul>
+    </div>
+  </div>
+</template>

package/src/components/RelationSphere.vue

@@ -21,6 +21,7 @@ import { easeInOutCubic, slerp, fibonacciSpherePosition, project, cardEdge, type
 import { UriRouter } from '../adapters/UriRouter';
 import { getPreferredTerm } from '../utils/concept-helpers';
 import { renderContent } from '../utils/content-renderer';
+import { hashSeed, expandParams, portSide, portPoint, idToUriGet } from '../utils/sphere-math';
 import { useI18n } from '../i18n';
 
 const { t, locale } = useI18n();
@@ -168,7 +169,7 @@ async function resolveTerm(
   uriBase: string,
   factory: ReturnType<typeof getFactory>
 ): Promise<ResolvedTerm | null> {
-  const neighborUri = `${uriBase}/${n.register}/concept/${n.conceptId}`;
+  const neighborUri = UriRouter.buildConceptUri(uriBase, n.register, n.conceptId);
   const out: ResolvedTerm = { term: null };
 
   /* Strategy 1: graph engine */
@@ -229,12 +230,6 @@ function updateNodeTerm(n: SNode) {
 
 /* ── Build internal graph from concept + edges (BFS) ────── */
 
-function hashSeed(s: string): number {
-  let h = 0;
-  for (let i = 0; i < s.length; i++) h = ((h << 5) - h + s.charCodeAt(i)) | 0;
-  return Math.abs(h);
-}
-
 function buildGraph() {
   const focusUri = conceptUri(props.concept, props.registerId, props.manifest.uriBase);
   const focusId = props.concept?.id || props.registerId;
@@ -399,11 +394,6 @@ function buildGraph() {
 }
 
 /* Reverse lookup: URI → node id. Linear scan is fine for ≤36 nodes. */
-function idToUriGet(map: Map<string, string>, uri: string): string | undefined {
-  for (const [id, u] of map) if (u === uri) return id;
-  return undefined;
-}
-
 /* ── Custom forces (EXACT prototype replica) ────────────── */
 function sphereConstraint() {
   let nL: SNode[] = nodes;
@@ -443,15 +433,6 @@ function velocityClamp(maxV: number) {
    visual difference between tight (0) and loose (10) is dramatic.
    Link distance is chord distance on the unit sphere: 0.5 ≈ 29° (cards
    cluster near focus), 1.95 ≈ 154° (cards spread to back hemisphere). */
-function expandParams(v: number): { linkDist: number; linkStrength: number; repMin: number; repStrength: number } {
-  const t = Math.max(0, Math.min(10, v)) / 10;
-  return {
-    linkDist: 0.5 + t * 1.45,         /* 0.5 → 1.95 */
-    linkStrength: 0.08,
-    repMin: 0.55 + t * 0.40,           /* 0.55 → 0.95 — just prevents overlap */
-    repStrength: 0.05,
-  };
-}
 let linkDistance = expandParams(5).linkDist;
 let linkStrength = expandParams(5).linkStrength;
 let repulseMinDist = expandParams(5).repMin;
@@ -606,24 +587,9 @@ function onTick() {
 /* ── Edge drawing with 4-port card connections + type labels ─ */
 /* Determine which side of a card (top/bottom/left/right) an edge should
    connect to, based on the direction to the other endpoint. */
-function portSide(from: {x:number;y:number}, to: {x:number;y:number}): 'top'|'bottom'|'left'|'right' {
-  const dx = to.x - from.x, dy = to.y - from.y;
-  if (Math.abs(dx) > Math.abs(dy)) return dx > 0 ? 'right' : 'left';
-  return dy > 0 ? 'bottom' : 'top';
-}
-
 /* Compute the connection point on a card's side, with an offset along
    that side so multiple edges to the same side don't stack on top of
    each other. `offset` is in [-1, 1] (0 = midpoint, ±1 = corners). */
-function portPoint(center: {x:number;y:number}, side: 'top'|'bottom'|'left'|'right', w: number, h: number, offset: number) {
-  switch (side) {
-    case 'right':  return { x: center.x + w/2, y: center.y + (h/2 - 6) * offset };
-    case 'left':   return { x: center.x - w/2, y: center.y + (h/2 - 6) * offset };
-    case 'bottom': return { x: center.x + (w/2 - 12) * offset, y: center.y + h/2 };
-    case 'top':    return { x: center.x + (w/2 - 12) * offset, y: center.y - h/2 };
-  }
-}
-
 function drawEdges(cx: number, cy: number) {
   const svg = edgesSvgRef.value; if (!svg) return;
   const w = cx * 2, h = cy * 2 / 0.46;

package/src/composables/use-concept-edges.ts

@@ -1,9 +1,10 @@
 import { computed, type ComputedRef } from 'vue';
 import type { Router } from 'vue-router';
-import type { Concept, RelatedConcept } from 'glossarist';
-import type { Manifest, GraphEdge } from '../adapters/types';
+import type { Concept, PartitiveHyperedge as GlsPartitiveHyperedge, RelatedConcept } from 'glossarist';
+import type { Manifest, GraphEdge, PartitiveHyperedge } from '../adapters/types';
 import { getFactory } from '../adapters/factory';
 import { conceptUri } from '../adapters/model-bridge';
+import { UriRouter } from '../adapters/UriRouter';
 import { useVocabularyStore } from '../stores/vocabulary';
 import { useDsStyle } from '../utils/dataset-style';
 import { categorizeRelationship, relationshipLabel, INVERSE_RELATIONSHIPS } from '../utils/relationship-categories';
@@ -111,9 +112,72 @@ export function useConceptEdges(
           content: '',
         };
       });
-    return [...direct, ...derived];
+    return [...direct, ...derived].filter(edge => {
+      if (edge.type === 'broader_partitive' || edge.type === 'narrower_partitive') {
+        const heUris = conceptPartitiveHyperedges.value;
+        return !heUris.some(he => he.parts.includes(edge.ref as string) || he.comprehensive === edge.ref);
+      }
+      return true;
+    });
   });
 
+  const VALID_MARKERS = new Set(['double', 'dashed']);
+
+  function validateHyperedgeMarkers(markers: Iterable<string>): ('double' | 'dashed')[] {
+    const out: ('double' | 'dashed')[] = [];
+    for (const m of markers) {
+      if (!VALID_MARKERS.has(m)) {
+        throw new Error(`Invalid partitive hyperedge marker: "${m}". Allowed: double, dashed`);
+      }
+      out.push(m as 'double' | 'dashed');
+    }
+    return out;
+  }
+
+  function resolveLocalizedContent(content: unknown): string | undefined {
+    if (content == null) return undefined;
+    if (typeof content === 'string') return content;
+    if (typeof content === 'object' && content !== null) {
+      const obj = content as Record<string, string>;
+      return obj[registerId.value] ?? obj.default ?? obj.eng ?? Object.values(obj)[0];
+    }
+    return undefined;
+  }
+
+  // Concept-level partitive hyperedges (one-to-many decompositions).
+  // Each hyperedge is resolved to concrete target URIs for display.
+  // Independent of binary `conceptRelated` — see TODO.hyperedge/00.
+  const conceptPartitiveHyperedges = computed<PartitiveHyperedge[]>(() => {
+    const source = conceptUriValue.value;
+    return (concept.value.partitiveHyperedges ?? [])
+      .map((he: GlsPartitiveHyperedge): PartitiveHyperedge | null => {
+        const comprehensive = resolveRefUri(he.comprehensive);
+        if (!comprehensive) return null;
+        const parts = he.parts
+          .map(resolveRefUri)
+          .filter((u): u is string => !!u && u !== source);
+        if (parts.length === 0) return null;
+        return {
+          source,
+          comprehensive,
+          parts,
+          enumeration: he.isOpen ? 'open' : 'closed',
+          markers: validateHyperedgeMarkers(he.markers),
+          label: resolveLocalizedContent(he.content),
+          register: registerId.value,
+        };
+      })
+      .filter((he): he is PartitiveHyperedge => he !== null);
+  });
+
+  function resolveRefUri(ref: { source?: string | null; id?: string | null } | null): string | null {
+    const target = resolveRelatedRef(ref);
+    if (!target) return null;
+    const m = store.manifests.get(target.registerId);
+    if (!m) return null;
+    return UriRouter.buildConceptUri(m.uriBase, target.registerId, target.conceptId);
+  }
+
   function resolveRelatedRef(ref: { source: string | null; id: string | null } | null) {
     return factory.resolveRelatedRef(ref, registerId.value);
   }
@@ -134,8 +198,15 @@ export function useConceptEdges(
     return resolvedRefs.value.get(key) ?? { target: resolveRelatedRef(ref) };
   }
 
-  function relatedLabel(dr: { content?: string | null; ref?: { source: string | null; id: string | null } | null }): string {
-    if (dr.content) return dr.content;
+  function relatedLabel(dr: { content?: Record<string, string> | string | null; ref?: { source: string | null; id: string | null } | null }): string {
+    if (dr.content) {
+      // Content is a localized hash { eng: "...", fra: "..." }.
+      // Legacy data may still carry a plain string; tolerate both.
+      const c = dr.content as Record<string, string> | string;
+      if (typeof c === 'string') return c;
+      const values = Object.values(c);
+      if (values.length > 0) return values[0];
+    }
     const resolved = dr.ref ? getResolvedRef(dr.ref).target : null;
     if (resolved) {
       const m = store.manifests.get(resolved.registerId);
@@ -173,6 +244,7 @@ export function useConceptEdges(
     edgeBadgeColor,
     inverseEdgeType,
     conceptRelated,
+    conceptPartitiveHyperedges,
     resolveRelatedRef,
     getResolvedRef,
     relatedLabel,

package/src/utils/hyperedge-styling.ts

@@ -0,0 +1,48 @@
+/**
+ * Hyperedge styling — colors for partitive decompositions.
+ *
+ * Independent of relationship-categories.ts (which handles binary edges).
+ * Hyperedges have their own visual language: teal base color, enumeration
+ * affects opacity, markers add accent badges.
+ */
+
+const BASE_LIGHT = '#0d9488';
+const BASE_DARK = '#2dd4bf';
+const ACCENT_DOUBLE_LIGHT = '#3b82f6';
+const ACCENT_DOUBLE_DARK = '#60a5fa';
+const ACCENT_DASHED_LIGHT = '#f59e0b';
+const ACCENT_DASHED_DARK = '#fbbf24';
+
+export interface HyperedgeStyle {
+  color: string;
+  badgeClass: string;
+  opacity: number;
+}
+
+export function hyperedgeStyle(
+  enumeration: 'closed' | 'open',
+  markers: string[],
+  isDark: boolean,
+): HyperedgeStyle {
+  const base = isDark ? BASE_DARK : BASE_LIGHT;
+  const opacity = enumeration === 'open' ? 0.6 : 1.0;
+
+  let badgeClass = 'badge-teal';
+  if (markers.includes('double')) {
+    badgeClass = isDark ? 'badge-blue' : 'badge-blue';
+  } else if (markers.includes('dashed')) {
+    badgeClass = 'badge-yellow';
+  }
+
+  return { color: base, badgeClass, opacity };
+}
+
+export function markerColor(marker: string, isDark: boolean): string {
+  if (marker === 'double') return isDark ? ACCENT_DOUBLE_DARK : ACCENT_DOUBLE_LIGHT;
+  if (marker === 'dashed') return isDark ? ACCENT_DASHED_DARK : ACCENT_DASHED_LIGHT;
+  return isDark ? BASE_DARK : BASE_LIGHT;
+}
+
+export function enumerationLabel(enumeration: 'closed' | 'open'): string {
+  return enumeration === 'open' ? 'Open (partial)' : 'Closed (complete)';
+}

package/src/utils/sphere-math.ts

@@ -0,0 +1,54 @@
+/** Deterministic hash from string → positive integer (for seeding positions). */
+export function hashSeed(s: string): number {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) h = ((h << 5) - h + s.charCodeAt(i)) | 0;
+  return Math.abs(h);
+}
+
+/** Expand-slider → simulation parameters. Maps [0, 10] to physical constants. */
+export function expandParams(v: number): {
+  linkDist: number;
+  linkStrength: number;
+  repMin: number;
+  repStrength: number;
+} {
+  const t = Math.max(0, Math.min(10, v)) / 10;
+  return {
+    linkDist: 0.5 + t * 1.45,
+    linkStrength: 0.08,
+    repMin: 0.55 + t * 0.40,
+    repStrength: 0.05,
+  };
+}
+
+/** Which side of a card does an edge connect to? */
+export function portSide(
+  from: { x: number; y: number },
+  to: { x: number; y: number },
+): 'top' | 'bottom' | 'left' | 'right' {
+  const dx = to.x - from.x, dy = to.y - from.y;
+  if (Math.abs(dx) > Math.abs(dy)) return dx > 0 ? 'right' : 'left';
+  return dy > 0 ? 'bottom' : 'top';
+}
+
+/** Connection point on a card's side, with offset to prevent stacking. */
+export function portPoint(
+  center: { x: number; y: number },
+  side: 'top' | 'bottom' | 'left' | 'right',
+  w: number,
+  h: number,
+  offset: number,
+): { x: number; y: number } {
+  switch (side) {
+    case 'right':  return { x: center.x + w / 2, y: center.y + (h / 2 - 6) * offset };
+    case 'left':   return { x: center.x - w / 2, y: center.y + (h / 2 - 6) * offset };
+    case 'bottom': return { x: center.x + (w / 2 - 12) * offset, y: center.y + h / 2 };
+    case 'top':    return { x: center.x + (w / 2 - 12) * offset, y: center.y - h / 2 };
+  }
+}
+
+/** Reverse lookup: find the node ID whose URI matches, in an ID→URI map. */
+export function idToUriGet(map: Map<string, string>, uri: string): string | undefined {
+  for (const [id, u] of map) if (u === uri) return id;
+  return undefined;
+}