@glossarist/concept-browser 0.7.76 → 0.7.78

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/AppSidebar.vue

@@ -136,7 +136,7 @@ const filteredGlobalPages = computed(() =>
 
 // Show only standard dataset pages (Concepts, Statistics, About)
 const filteredDatasetPages = computed(() =>
-  datasetPages.value.filter(p => ['', 'stats', 'about'].includes(p.route || ''))
+  datasetPages.value.filter(p => ['', 'stats', 'sources', 'about'].includes(p.route || ''))
 );
 
 const currentManifest = computed(() => store.manifests.get(currentDataset.value));

package/src/components/NavIcon.vue

@@ -9,6 +9,7 @@ const icons: Record<string, string> = {
   chart: 'M9 19v-6a2 2 0 00-2-2H5a2 2 0 00-2 2v6a2 2 0 002 2h2a2 2 0 002-2zm0 0V9a2 2 0 012-2h2a2 2 0 012 2v10m-6 0a2 2 0 002 2h2a2 2 0 002-2m0 0V5a2 2 0 012-2h2a2 2 0 012 2v14a2 2 0 01-2 2h-2a2 2 0 01-2-2z',
   list: 'M4 6h16M4 10h16M4 14h16M4 18h16',
   schema: 'M4 5a1 1 0 011-1h14a1 1 0 011 1v2a1 1 0 01-1 1H5a1 1 0 01-1-1V5zM4 13a1 1 0 011-1h6a1 1 0 011 1v6a1 1 0 01-1 1H5a1 1 0 01-1-1v-6zM16 13a1 1 0 011-1h2a1 1 0 011 1v6a1 1 0 01-1 1h-2a1 1 0 01-1-1v-6z',
+  database: 'M4 7c0 1.1 3.6 2 8 2s8-.9 8-2M4 7c0-1.1 3.6-2 8-2s8 .9 8 2M4 7v10c0 1.1 3.6 2 8 2s8-.9 8-2V7M4 12c0 1.1 3.6 2 8 2s8-.9 8-2',
 };
 
 defineProps<{ name: 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,