@glossarist/concept-browser 0.7.93 → 0.7.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.93",
+  "version": "0.7.95",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {

package/scripts/generate-data.mjs

@@ -91,6 +91,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.generic_relations) result._genericRelations = mc.generic_relations;
     if (mc.data.domains) result._domains = mc.data.domains;
     if (mc.dates) result._dates = mc.dates;
     if (mc.sources) result._sources = mc.sources;
@@ -769,6 +770,54 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
     });
   }
 
+  if (conceptYaml._genericRelations?.length > 0) {
+    doc['gl:genericRelations'] = conceptYaml._genericRelations.map(rel => {
+      const out = { '@type': 'gl:GenericRelation' };
+      if (rel.comprehensive) {
+        out['gl:comprehensive'] = refToJsonLd(rel.comprehensive, 'gl:ConceptRef');
+      }
+      if (Array.isArray(rel.members) && rel.members.length > 0) {
+        out['gl:hasGeneric'] = rel.members.map(member => {
+          const m = { '@type': 'gl:GenericMember' };
+          if (member.ref) {
+            m['gl:ref'] = refToJsonLd(member.ref, 'gl:ConceptRef');
+          } else {
+            m['gl:ref'] = refToJsonLd(member, 'gl:ConceptRef');
+          }
+          const presence = member.presence
+            ?? splitMultiplicity(member.multiplicity ?? '').presence;
+          const count = member.count
+            ?? splitMultiplicity(member.multiplicity ?? '').count;
+          m['gl:presence'] = presence;
+          m['gl:count'] = count;
+          /* ISO 704:2022 §5.5.4.2.1 — every generic member carries a
+             delimiting characteristic that distinguishes it from its
+             coordinate concepts. Required field. */
+          if (member.delimiting_characteristic || member.delimitingCharacteristic) {
+            const dc = member.delimiting_characteristic ?? member.delimitingCharacteristic;
+            m['gl:delimitingCharacteristic'] = typeof dc === 'string'
+              ? { default: dc }
+              : dc;
+          }
+          if (member.multiplicity) m['gl:multiplicity'] = member.multiplicity;
+          const legacyCertainty = member.certainty
+            ?? LEGACY_CERTAINTY_FROM_AXIS[presence];
+          if (legacyCertainty) m['gl:certainty'] = legacyCertainty;
+          return m;
+        });
+      }
+      if (rel.completeness) {
+        out['gl:completeness'] = rel.completeness;
+      }
+      if (rel.criterion) {
+        out['gl:criterion'] = typeof rel.criterion === 'string'
+          ? { default: rel.criterion }
+          : rel.criterion;
+      }
+      return out;
+    });
+  }
+
   return doc;
 }
 

package/src/__tests__/__fixtures__/concepts.ts

@@ -204,6 +204,65 @@ function withdrawnConcept(): Concept {
   });
 }
 
+function withPartitiveHyperedge(): Concept {
+  const source = 'urn:glossarist:fixtures';
+  return Concept.fromJSON({
+    id: '1.3',
+    uri: `${BASE}/with-partitive-hyperedge`,
+    status: 'valid',
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: 'system of quantities', normative_status: 'preferred' }],
+        definition: [{ content: 'A concept that has a partitive decomposition.' }],
+      },
+    },
+    relations: [
+      {
+        type: 'partitive_relation',
+        comprehensive: { source, id: '1.3' },
+        members: [
+          { ref: { source, id: '1.22' }, presence: 'required', count: 'at_least_one' },
+          { ref: { source, id: '1.4' },  presence: 'required', count: 'multiple' },
+          { ref: { source, id: '1.5' },  presence: 'required', count: 'at_least_one' },
+        ],
+        completeness: 'complete',
+      },
+    ],
+  });
+}
+
+function withGenericHyperedge(): Concept {
+  const source = 'urn:glossarist:fixtures';
+  return Concept.fromJSON({
+    id: '1.9',
+    uri: `${BASE}/with-generic-hyperedge`,
+    status: 'valid',
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: 'measurement unit', normative_status: 'preferred' }],
+        definition: [{ content: 'A concept that has a generic (genus/species) decomposition.' }],
+      },
+    },
+    relations: [
+      {
+        type: 'generic_relation',
+        comprehensive: { source, id: '1.9' },
+        criterion: { eng: 'by magnitude relationship to a reference unit' },
+        members: [
+          { ref: { source, id: '1.17' }, presence: 'required', count: 'at_least_one', delimitingCharacteristic: { eng: 'multiple of a unit' } },
+          { ref: { source, id: '1.18' }, presence: 'required', count: 'at_least_one', delimitingCharacteristic: { eng: 'submultiple of a unit' } },
+          { ref: { source, id: '1.12' }, presence: 'required', count: 'at_least_one', delimitingCharacteristic: { eng: 'coherent derived unit' } },
+        ],
+        completeness: 'partial',
+      },
+    ],
+  });
+}
+
 export const CONCEPT_FIXTURES: readonly ConceptFixture[] = [
   { name: 'minimal',            description: 'one localization, one designation',                uri: `${BASE}/minimal`,            concept: minimal() },
   { name: 'multilingual',       description: 'three languages across Latn and CJK scripts',      uri: `${BASE}/multilingual`,       concept: multilingual() },
@@ -212,6 +271,8 @@ export const CONCEPT_FIXTURES: readonly ConceptFixture[] = [
   { name: 'with-non-verbal',    description: 'figure, formula, and table non-verbal reps',       uri: `${BASE}/with-non-verbal`,    concept: withNonVerbal() },
   { name: 'with-dates',         description: 'accepted/amended/retired lifecycle',               uri: `${BASE}/with-dates`,         concept: withDates() },
   { name: 'withdrawn',          description: 'withdrawn status with retirement date (J3)',        uri: `${BASE}/withdrawn`,          concept: withdrawnConcept() },
+  { name: 'with-partitive-hyperedge', description: 'partitive decomposition in concept.relations', uri: `${BASE}/with-partitive-hyperedge`, concept: withPartitiveHyperedge() },
+  { name: 'with-generic-hyperedge',   description: 'generic (genus/species) decomposition in concept.relations', uri: `${BASE}/with-generic-hyperedge`, concept: withGenericHyperedge() },
 ];
 
 export function fixtureByName(name: string): ConceptFixture {

package/src/__tests__/composables/use-concept-edges-hyperedge.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { computed, ref } from 'vue';
+import type { Router } from 'vue-router';
+import { useConceptEdges } from '../../composables/use-concept-edges';
+import { useVocabularyStore } from '../../stores/vocabulary';
+import type { Manifest, GraphEdge } from '../../adapters/types';
+import { makeManifest, setupPinia } from '../test-helpers';
+import { fixtureByName } from '../__fixtures__/concepts';
+import { getFactory, resetFactory } from '../../adapters/factory';
+
+/**
+ * Regression test for the sphere-view hyperedge projection.
+ *
+ * Bug (2026-07-30): ConceptView.vue read `concept.partitiveRelations`
+ * — a field glossarist 0.4.34 REMOVED. The field was silently
+ * `undefined`, the sphere rendered no rake, and no test caught it.
+ *
+ * Fix: ConceptView consumes `useConceptEdges.conceptPartitiveRelations`,
+ * which reads the unified `concept.relations` array and filters by
+ * `instanceof PartitiveHyperedge`. This spec pins that contract —
+ * if glossarist ever renames or removes `.relations`, this fails.
+ */
+describe('useConceptEdges — hyperedge projection (regression)', () => {
+  const URN_SOURCE = 'urn:glossarist:fixtures';
+  const manifest: Manifest = makeManifest({
+    id: 'fixtures',
+    datasetUri: URN_SOURCE,
+    uriBase: 'https://glossarist.org',
+  });
+  const noEdges: GraphEdge[] = [];
+  const noopRouter = { push() {} } as unknown as Router;
+
+  let store: ReturnType<typeof useVocabularyStore>;
+
+  beforeEach(() => {
+    setupPinia();
+    resetFactory();
+    store = useVocabularyStore();
+    store.manifests.set(manifest.id, manifest);
+
+    const factory = getFactory();
+    factory.resolveRelatedRef = vi.fn((ref: { source: string | null; id: string | null } | null) =>
+      ref?.source === URN_SOURCE && ref.id
+        ? { registerId: manifest.id, conceptId: ref.id }
+        : null,
+    );
+  });
+
+  it('projects a PartitiveHyperedge from concept.relations', () => {
+    const { concept } = fixtureByName('with-partitive-hyperedge');
+    const { conceptPartitiveRelations } = useConceptEdges(
+      computed(() => concept),
+      computed(() => 'fixtures'),
+      computed(() => manifest),
+      computed(() => noEdges),
+      noopRouter,
+    );
+
+    const rels = conceptPartitiveRelations.value;
+    expect(rels).toHaveLength(1);
+
+    const [rel] = rels;
+    expect(rel.comprehensive).toBe('https://glossarist.org/fixtures/concept/1.3');
+    expect(rel.partitives).toHaveLength(3);
+    expect(rel.partitives.map(m => m.uri)).toEqual([
+      'https://glossarist.org/fixtures/concept/1.22',
+      'https://glossarist.org/fixtures/concept/1.4',
+      'https://glossarist.org/fixtures/concept/1.5',
+    ]);
+    expect(rel.partitives[1].presence).toBe('required');
+    expect(rel.partitives[1].count).toBe('multiple');
+  });
+
+  it('returns [] when concept is null (loading state)', () => {
+    const { conceptPartitiveRelations, conceptGenericRelations } = useConceptEdges(
+      computed(() => null),
+      computed(() => 'fixtures'),
+      computed(() => manifest),
+      computed(() => noEdges),
+      noopRouter,
+    );
+    expect(conceptPartitiveRelations.value).toEqual([]);
+    expect(conceptGenericRelations.value).toEqual([]);
+  });
+
+  it('returns [] when manifest is null', () => {
+    const { concept } = fixtureByName('with-partitive-hyperedge');
+    const { conceptPartitiveRelations } = useConceptEdges(
+      computed(() => concept),
+      computed(() => 'fixtures'),
+      computed(() => null),
+      computed(() => noEdges),
+      noopRouter,
+    );
+    expect(conceptPartitiveRelations.value).toEqual([]);
+  });
+
+  it('would have caught the .partitiveRelations regression', () => {
+    // Simulate the pre-fix behavior: the old code read concept.partitiveRelations
+    // (undefined in glossarist 0.4.34+) and produced an empty array.
+    // This spec proves the projection now reads concept.relations instead.
+    const { concept } = fixtureByName('with-partitive-hyperedge');
+    expect((concept as any).partitiveRelations).toBeUndefined();
+    expect((concept as any).relations).toHaveLength(1);
+
+    const { conceptPartitiveRelations } = useConceptEdges(
+      computed(() => concept),
+      computed(() => 'fixtures'),
+      computed(() => manifest),
+      computed(() => noEdges),
+      noopRouter,
+    );
+    expect(conceptPartitiveRelations.value.length).toBe(1);
+  });
+
+  it('projects a GenericHyperedge from concept.relations', () => {
+    const { concept } = fixtureByName('with-generic-hyperedge');
+    const { conceptGenericRelations } = useConceptEdges(
+      computed(() => concept),
+      computed(() => 'fixtures'),
+      computed(() => manifest),
+      computed(() => noEdges),
+      noopRouter,
+    );
+
+    const rels = conceptGenericRelations.value;
+    expect(rels).toHaveLength(1);
+
+    const [rel] = rels;
+    expect(rel.comprehensive).toBe('https://glossarist.org/fixtures/concept/1.9');
+    expect(rel.members).toHaveLength(3);
+    expect(rel.members.map(m => m.uri)).toEqual([
+      'https://glossarist.org/fixtures/concept/1.17',
+      'https://glossarist.org/fixtures/concept/1.18',
+      'https://glossarist.org/fixtures/concept/1.12',
+    ]);
+    /* ISO 704:2022 §5.5.4.2.1 — every generic member carries a
+       delimiting characteristic. Pin the field is projected. */
+    expect(rel.members[0].delimitingCharacteristic).toEqual({ eng: 'multiple of a unit' });
+    expect(rel.members[1].delimitingCharacteristic).toEqual({ eng: 'submultiple of a unit' });
+    expect(rel.criterion).toEqual({ eng: 'by magnitude relationship to a reference unit' });
+  });
+});

package/src/__tests__/composables/use-concept-edges-v2.test.ts

@@ -39,7 +39,7 @@ function makePartitive(
   if (fields.presence) data.presence = fields.presence;
   if (fields.count) data.count = fields.count;
   if (fields.isDelimiting) data.is_delimiting = fields.isDelimiting;
-  return new PartitiveMemberModel(data as any) as PartitiveMember;
+  return new (PartitiveMemberModel as unknown as new (data: unknown) => PartitiveMember)(data) as PartitiveMember;
 }
 
 function makeRelation(opts: {
@@ -48,7 +48,7 @@ function makeRelation(opts: {
   completeness?: 'complete' | 'partial';
   criterion?: Record<string, string>;
 }): PartitiveHyperedge {
-  return new PartitiveHyperedgeModel(opts as any) as PartitiveHyperedge;
+  return new (PartitiveHyperedgeModel as unknown as new (data: unknown) => PartitiveHyperedge)(opts) as PartitiveHyperedge;
 }
 
 describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () => {

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { hashSeed, expandParams, portSide, portPoint, idToUriGet } from '../utils/sphere-math';
+import { hashSeed, expandParams, portSide, portPoint, idToUriGet, visibleNodeIds } from '../utils/sphere-math';
 
 describe('sphere-math', () => {
   describe('hashSeed', () => {
@@ -53,4 +53,111 @@ describe('sphere-math', () => {
       expect(idToUriGet(map, '/uri/unknown')).toBeUndefined();
     });
   });
+
+  describe('visibleNodeIds', () => {
+    const focus = { id: 'focus', register: 'main', depth: 0 };
+    const a = { id: 'a', register: 'main', depth: 1 };
+    const b = { id: 'b', register: 'main', depth: 1 };
+    const c = { id: 'c', register: 'main', depth: 1 };
+    const d = { id: 'd', register: 'other', depth: 1 };
+
+    const buildLinks = (links: Array<[string, string, string]>) =>
+      links.map(([source, target, type]) => ({ source, target, type }));
+
+    it('always includes the focus node (depth 0)', () => {
+      const nodes = [focus, a];
+      const links = buildLinks([['focus', 'a', 'related']]);
+      const visible = visibleNodeIds(nodes, links, new Set(), new Set());
+      expect(visible.has('focus')).toBe(true);
+    });
+
+    it('includes a node that has at least one non-muted edge', () => {
+      const nodes = [focus, a, b];
+      const links = buildLinks([
+        ['focus', 'a', 'related'],
+        ['focus', 'b', 'see'],
+      ]);
+      const visible = visibleNodeIds(nodes, links, new Set(), new Set());
+      expect(visible.has('a')).toBe(true);
+      expect(visible.has('b')).toBe(true);
+    });
+
+    it('hides a node whose only edge type is muted', () => {
+      const nodes = [focus, a, b];
+      const links = buildLinks([
+        ['focus', 'a', 'related'],
+        ['focus', 'b', 'see'],
+      ]);
+      const visible = visibleNodeIds(nodes, links, new Set(['see']), new Set());
+      expect(visible.has('a')).toBe(true);
+      expect(visible.has('b')).toBe(false);
+    });
+
+    it('vice versa: hidden node reappears when type is unmuted', () => {
+      const nodes = [focus, a, b];
+      const links = buildLinks([
+        ['focus', 'a', 'related'],
+        ['focus', 'b', 'see'],
+      ]);
+      const muted = new Set(['see']);
+      expect(visibleNodeIds(nodes, links, muted, new Set()).has('b')).toBe(false);
+      muted.delete('see');
+      expect(visibleNodeIds(nodes, links, muted, new Set()).has('b')).toBe(true);
+    });
+
+    it('keeps a node visible if it has at least one unmuted edge among several', () => {
+      const nodes = [focus, a, b, c];
+      const links = buildLinks([
+        ['focus', 'a', 'related'],
+        ['focus', 'a', 'see'],
+        ['focus', 'b', 'see'],
+        ['focus', 'c', 'related'],
+      ]);
+      const visible = visibleNodeIds(nodes, links, new Set(['see']), new Set());
+      expect(visible.has('a')).toBe(true);
+      expect(visible.has('b')).toBe(false);
+      expect(visible.has('c')).toBe(true);
+    });
+
+    it('hides a node in a muted register (unless it is the focus)', () => {
+      const nodes = [focus, a, d];
+      const links = buildLinks([
+        ['focus', 'a', 'related'],
+        ['focus', 'd', 'related'],
+      ]);
+      const visible = visibleNodeIds(nodes, links, new Set(), new Set(['other']));
+      expect(visible.has('a')).toBe(true);
+      expect(visible.has('d')).toBe(false);
+    });
+
+    it('hides a node whose only edge endpoint is in a muted register', () => {
+      const nodes = [focus, a, d];
+      const links = buildLinks([
+        ['a', 'd', 'related'],
+      ]);
+      const visible = visibleNodeIds(nodes, links, new Set(), new Set(['other']));
+      expect(visible.has('a')).toBe(false);
+      expect(visible.has('d')).toBe(false);
+    });
+
+    it('isolated non-focus node (no edges at all) is hidden', () => {
+      const nodes = [focus, a];
+      const links: Array<{ source: string; target: string; type: string }> = [];
+      const visible = visibleNodeIds(nodes, links, new Set(), new Set());
+      expect(visible.has('focus')).toBe(true);
+      expect(visible.has('a')).toBe(false);
+    });
+
+    it('all-visible when no mutes are set', () => {
+      const nodes = [focus, a, b, c, d];
+      const links = buildLinks([
+        ['focus', 'a', 'related'],
+        ['focus', 'b', 'see'],
+        ['focus', 'c', 'related'],
+        ['focus', 'd', 'references'],
+      ]);
+      const visible = visibleNodeIds(nodes, links, new Set(), new Set());
+      expect([...visible].sort()).toEqual(['a', 'b', 'c', 'd', 'focus']);
+    });
+  });
 });

package/src/adapters/non-verbal/glossarist-augment.d.ts

@@ -171,8 +171,6 @@ declare module 'glossarist' {
 
   interface Concept {
     readonly relations: AbstractHyperedge[];
-    readonly partitiveRelations: PartitiveHyperedge[];
-    readonly genericRelations: GenericHyperedge[];
   }
 
   // Re-exposed here so callers importing from the top-level `glossarist`

package/src/components/ConceptRdfView.vue

@@ -10,12 +10,14 @@ import { useRdfDocument } from './use-rdf-document';
 const props = defineProps<{
   concept: Concept;
   registerId: string;
-  conceptUriValue: string;
+  conceptUriValue: string | null;
 }>();
 
+const uri = computed(() => props.conceptUriValue ?? '');
+
 const { sections, turtle, jsonld, typeChain } = useRdfDocument(
   () => props.concept,
-  () => props.conceptUriValue,
+  () => uri.value,
 );
 
 const resourceCount = computed(() => sections.value.length);
@@ -23,11 +25,11 @@ const conceptId = computed(() => props.concept.id);
 </script>
 
 <template>
-  <ErrorBoundary title="RDF view failed" :retry-key="conceptUriValue">
+  <ErrorBoundary title="RDF view failed" :retry-key="uri">
     <div class="space-y-6">
       <div class="card p-5">
         <div class="flex items-start justify-between gap-3">
-          <RdfInstanceHeader :uri="conceptUriValue" :concept-id="conceptId" />
+          <RdfInstanceHeader :uri="uri" :concept-id="conceptId" />
         </div>
         <div class="mt-4 pt-3 border-t border-ink-100/60">
           <div class="flex items-center gap-1.5 flex-wrap text-xs text-ink-400">

package/src/components/RelationSphere.vue

@@ -21,11 +21,11 @@ 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 { hashSeed, expandParams, portSide, portPoint, idToUriGet, visibleNodeIds } from '../utils/sphere-math';
 import { useI18n } from '../i18n';
 
 const { t, locale } = useI18n();
-import type { Concept, Manifest, GraphEdge, PartitiveRelationWire, PartitiveMemberWire } from '../adapters/types';
+import type { Concept, Manifest, GraphEdge, PartitiveRelationWire, PartitiveMemberWire, GenericRelationWire } from '../adapters/types';
 import { rakeStrokeStyle } from '../utils/partitive-multiplicity';
 import { drawRakeBundles } from './relation-sphere/rake-bundles';
 import { ensureMarkers, ensureTypeMarker } from './relation-sphere/svg-markers';
@@ -45,6 +45,7 @@ const props = defineProps<{
   registerId: string;
   edges: GraphEdge[];
   partitiveRelations?: PartitiveRelationWire[];
+  genericRelations?: GenericRelationWire[];
 }>();
 
 const emit = defineEmits<{
@@ -403,16 +404,22 @@ function buildGraph() {
   nodes = Array.from(nodeMap.values());
   links = resultLinks;
 
-  /* Ensure every PartitiveRelation member is present in the graph
-     so the rake bundle can render. The comprehensive is normally the
-     focus; partitives may need to be added as depth-1 neighbors. */
-  for (const rel of props.partitiveRelations ?? []) {
+  /* Ensure every PartitiveRelation + GenericRelation member is present
+     in the graph so rake bundles can render. The comprehensive is
+     normally the focus; members may need to be added as depth-1
+     neighbors. */
+  const hyperedgeRelations: ReadonlyArray<PartitiveRelationWire | GenericRelationWire> = [
+    ...(props.partitiveRelations ?? []),
+    ...(props.genericRelations ?? []),
+  ];
+  for (const rel of hyperedgeRelations) {
     const compParsed = UriRouter.parseUri(rel.comprehensive);
     if (!compParsed) continue;
     const compNodeId = `${compParsed.registerId}/${compParsed.conceptId}`;
     if (!nodeMap.has(compNodeId)) continue;
 
-    for (const member of rel.partitives) {
+    const members = 'partitives' in rel ? rel.partitives : rel.members;
+    for (const member of members) {
       const parsed = UriRouter.parseUri(member.uri);
       if (!parsed) continue;
       const nid = `${parsed.registerId}/${parsed.conceptId}`;
@@ -691,6 +698,30 @@ function drawEdges(cx: number, cy: number) {
     isMuted: mutedTypes.value.has('__partitive__'),
     relations: props.partitiveRelations ?? [],
   });
+
+  /* Generic relations render as rake bundles in a distinct hue (amber).
+     Member shape differs (delimitingCharacteristic instead of isDelimiting),
+     so normalize to the partitive-shaped input the renderer expects. */
+  const genericNormalized: PartitiveRelationWire[] = (props.genericRelations ?? []).map(rel => ({
+    source: rel.source,
+    comprehensive: rel.comprehensive,
+    completeness: rel.completeness,
+    register: rel.register,
+    partitives: rel.members.map(m => ({
+      uri: m.uri,
+      presence: m.presence,
+      count: m.count,
+      /* Every generic member is delimiting by definition (each carries
+         its own delimiting characteristic per ISO 704 §5.5.4.2.1). */
+      isDelimiting: true,
+    })),
+  }));
+  drawRakeBundles(svg, pos, {
+    isDark: uiStore.isDark,
+    color: uiStore.isDark ? '#fbbf24' : '#b45309',
+    isMuted: mutedTypes.value.has('__generic__'),
+    relations: genericNormalized,
+  });
 }
 
 /* ── Render DOM nodes ───────────────────────────────────── */
@@ -702,9 +733,13 @@ function renderDOM() {
   const cx = c ? c.clientWidth / 2 : 0;
   const cy = c ? c.clientHeight * 0.46 : 0;
 
+  /* Cards with no visible edges (after applying type + register mutes)
+     float with no connections — hide them so toggling a relation type
+     cleans up orphaned cards. Focus node (depth 0) always renders. */
+  const visibleIds = visibleNodeIds(nodes, links, mutedTypes.value, mutedRegisters.value);
+
   for (const n of nodes) {
-    /* Skip muted-register nodes (except focus) */
-    if (n.depth !== 0 && mutedRegisters.value.has(n.register)) continue;
+    if (!visibleIds.has(n.id)) continue;
 
     const dsColor = getColor(n.register) || '#888';
     const el = document.createElement('div');
@@ -1020,6 +1055,16 @@ const legendItems = computed(() => {
       count: partitiveCount,
     });
   }
+  /* Synthetic entry for GenericRelations — same idea, distinct hue. */
+  const genericCount = props.genericRelations?.length ?? 0;
+  if (genericCount > 0) {
+    typeMap.set('__generic__', {
+      type: '__generic__',
+      label: 'generic relation',
+      color: uiStore.isDark ? '#fbbf24' : '#b45309',
+      count: genericCount,
+    });
+  }
   return Array.from(typeMap.values()).sort((a, b) => b.count - a.count);
 });
 
@@ -1164,6 +1209,9 @@ function toggleType(type: string) {
   mutedTypes.value = n;
   const c = canvasRef.value;
   if (c) drawEdges(c.clientWidth / 2, c.clientHeight * 0.46);
+  /* Re-render cards so nodes whose only edges were the toggled type
+     disappear (and reappear when the type is unmuted). */
+  renderDOM();
   /* Re-heat the simulation so nodes drift to a new equilibrium with
      the freed/hidden edges. The link force reads mutedTypes each tick,
      so toggling effectively "removes" the edge from the force calc. */

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

@@ -39,9 +39,9 @@ export interface EdgeDisplay {
 }
 
 export function useConceptEdges(
-  concept: ComputedRef<Concept>,
+  concept: ComputedRef<Concept | null | undefined>,
   registerId: ComputedRef<string>,
-  manifest: ComputedRef<Manifest>,
+  manifest: ComputedRef<Manifest | null | undefined>,
   edges: ComputedRef<GraphEdge[]>,
   router: Router,
 ) {
@@ -50,24 +50,30 @@ export function useConceptEdges(
   const { getColor } = useDsStyle();
   const { locale } = useI18n();
 
-  const conceptUriValue = computed(() =>
-    conceptUri(concept.value, registerId.value, manifest.value.uriBase)
-  );
+  const conceptUriValue = computed(() => {
+    if (!concept.value || !manifest.value) return null;
+    return conceptUri(concept.value, registerId.value, manifest.value.uriBase);
+  });
 
-  const outgoingEdges = computed(() =>
-    store.graph.getUniqueEdges(conceptUriValue.value, 'outgoing', 'target')
-      .filter(e => e.type !== 'domain' && e.type !== 'section')
-  );
+  const outgoingEdges = computed(() => {
+    const uri = conceptUriValue.value;
+    if (!uri) return [];
+    return store.graph.getUniqueEdges(uri, 'outgoing', 'target')
+      .filter(e => e.type !== 'domain' && e.type !== 'section');
+  });
 
-  const incomingEdges = computed(() =>
-    store.graph.getUniqueEdges(conceptUriValue.value, 'incoming', 'source')
-      .filter(e => e.type !== 'domain' && e.type !== 'section')
-  );
+  const incomingEdges = computed(() => {
+    const uri = conceptUriValue.value;
+    if (!uri) return [];
+    return store.graph.getUniqueEdges(uri, 'incoming', 'source')
+      .filter(e => e.type !== 'domain' && e.type !== 'section');
+  });
 
   const edgeDisplayCache = computed(() => {
     const cache = new Map<string, EdgeDisplay>();
+    const focusUri = conceptUriValue.value;
     for (const e of edges.value) {
-      const uri = e.source === conceptUriValue.value ? e.target : e.source;
+      const uri = e.source === focusUri ? e.target : e.source;
       if (cache.has(uri)) continue;
       const resolution = factory.resolve(uri, registerId.value);
       const isLocal = resolution.type === 'internal' && resolution.registerId === registerId.value;
@@ -131,6 +137,7 @@ export function useConceptEdges(
 
   // Concept-level related concepts (managed concept cross-references)
   const conceptRelated = computed(() => {
+    if (!concept.value) return [];
     const direct = concept.value.relatedConcepts?.filter(rc => !INVERSE_RELATIONSHIPS[rc.type]) ?? [];
     const derived = incomingEdges.value
       .filter(e => INVERSE_RELATIONSHIPS[e.type])
@@ -169,6 +176,7 @@ export function useConceptEdges(
   // discrimination is via instanceof.
   function projectHyperedge(rel: any): PartitiveRelationWire | GenericRelationWire | null {
     const source = conceptUriValue.value;
+    if (!source) return null;
     const comprehensive = resolveConceptRefUri(rel.comprehensive);
     if (!comprehensive) return null;
     const isGeneric = rel instanceof GenericHyperedge;
@@ -202,14 +210,16 @@ export function useConceptEdges(
   }
 
   const conceptPartitiveRelations = computed<PartitiveRelationWire[]>(() => {
-    return (concept.value.relations as any[] ?? [])
+    if (!concept.value) return [];
+    return ((concept.value.relations as any[]) ?? [])
       .filter(r => r instanceof PartitiveHyperedge)
       .map(projectHyperedge)
       .filter((r): r is PartitiveRelationWire => r !== null);
   });
 
   const conceptGenericRelations = computed<GenericRelationWire[]>(() => {
-    return (concept.value.relations as any[] ?? [])
+    if (!concept.value) return [];
+    return ((concept.value.relations as any[]) ?? [])
       .filter(r => r instanceof GenericHyperedge)
       .map(projectHyperedge)
       .filter((r): r is GenericRelationWire => r !== null);

package/src/utils/sphere-math.ts

@@ -52,3 +52,57 @@ export function idToUriGet(map: Map<string, string>, uri: string): string | unde
   for (const [id, u] of map) if (u === uri) return id;
   return undefined;
 }
+
+export interface SphereNodeLike {
+  id: string;
+  register: string;
+  depth: number;
+}
+
+export interface SphereLinkLike {
+  source: string;
+  target: string;
+  type: string;
+}
+
+/**
+ * IDs of nodes that should render given the current mute state.
+ *
+ * The focus node (depth 0) is always visible. Every other node must have
+ * at least one edge whose type is not muted AND whose other endpoint is
+ * not in a muted register — otherwise the card floats with no connections
+ * and should disappear when its relations are hidden.
+ *
+ * Extracted as a pure function so the visibility contract can be tested
+ * without mounting the sphere component.
+ */
+export function visibleNodeIds(
+  nodes: readonly SphereNodeLike[],
+  links: readonly SphereLinkLike[],
+  mutedTypes: ReadonlySet<string>,
+  mutedRegisters: ReadonlySet<string>,
+): Set<string> {
+  const byId = new Map<string, SphereNodeLike>();
+  for (const n of nodes) byId.set(n.id, n);
+
+  const visible = new Set<string>();
+  for (const n of nodes) {
+    if (n.depth === 0) {
+      visible.add(n.id);
+      continue;
+    }
+    if (mutedRegisters.has(n.register)) continue;
+    for (const l of links) {
+      if (mutedTypes.has(l.type)) continue;
+      const otherId = l.source === n.id ? l.target : l.target === n.id ? l.source : null;
+      if (!otherId) continue;
+      const other = byId.get(otherId);
+      if (!other) continue;
+      if (other.depth !== 0 && mutedRegisters.has(other.register)) continue;
+      visible.add(n.id);
+      break;
+    }
+  }
+  return visible;
+}
+

package/src/views/ConceptView.vue

@@ -2,14 +2,10 @@
 import { computed, watch, ref, onMounted, onUnmounted } from 'vue';
 import { useRouter } from 'vue-router';
 import { useVocabularyStore } from '../stores/vocabulary';
-import { conceptUri } from '../adapters/model-bridge';
-import { UriRouter } from '../adapters/UriRouter';
-import type { PartitiveRelationWire, PartitiveMemberWire } from '../adapters/types';
-import type { PartitiveMember } from 'glossarist/models';
-import type { PartitivePresence, PartitiveCount } from '../utils/partitive-multiplicity';
 import ConceptDetail from '../components/ConceptDetail.vue';
 import RelationSphere from '../components/RelationSphere.vue';
 import ShortcutsModal from '../components/ShortcutsModal.vue';
+import { useConceptEdges } from '../composables/use-concept-edges';
 import { useI18n } from '../i18n';
 
 const { t } = useI18n();
@@ -63,47 +59,13 @@ const edges = computed(() => store.conceptEdges);
 const activeRegisterId = computed(() => sphereFocusPayload.value?.registerId ?? props.registerId);
 const adjacent = ref({ prev: null as string | null, next: null as string | null });
 
-/**
- * Project concept.partitiveRelations (glossarist-js v2 model) into the
- * URI-resolved wire shape the sphere consumes. Mirrors the projection
- * in use-concept-edges.ts but inline here so the sphere can render rake
- * bundles without a full composable setup.
- */
-const partitiveRelationsForSphere = computed<PartitiveRelationWire[]>(() => {
-  const c = concept.value;
-  const m = manifest.value;
-  if (!c || !m) return [];
-  const sourceUri = conceptUri(c, activeRegisterId.value, m.uriBase);
-  const out: PartitiveRelationWire[] = [];
-  for (const rel of c.partitiveRelations ?? []) {
-    const compRef = rel.comprehensive;
-    const compTarget = store.manifests.get(activeRegisterId.value)
-      ? UriRouter.buildConceptUri(m.uriBase, activeRegisterId.value, compRef.id ?? '')
-      : null;
-    if (!compRef.id || !compTarget) continue;
-    const partitives: PartitiveMemberWire[] = rel.partitives
-      .map((member): PartitiveMemberWire | null => {
-        const ref = member.ref;
-        if (!ref?.id) return null;
-        const uri = UriRouter.buildConceptUri(m.uriBase, activeRegisterId.value, ref.id);
-        if (uri === sourceUri) return null;
-        const presence: PartitivePresence = member.presence;
-        const count: PartitiveCount = member.count;
-        const isDelimiting = (member as any).is_delimiting === true;
-        return { uri, presence, count, isDelimiting };
-      })
-      .filter((x): x is PartitiveMemberWire => x !== null);
-    if (partitives.length === 0) continue;
-    out.push({
-      source: sourceUri,
-      comprehensive: compTarget,
-      partitives,
-      completeness: rel.completeness,
-      register: activeRegisterId.value,
-    });
-  }
-  return out;
-});
+const { conceptPartitiveRelations, conceptGenericRelations } = useConceptEdges(
+  concept,
+  activeRegisterId,
+  manifest,
+  edges,
+  router,
+);
 const viewMode = ref<'detail' | 'sphere'>(
   router.currentRoute.value.query.view === 'sphere' ? 'sphere' : 'detail'
 );
@@ -326,7 +288,8 @@ onUnmounted(() => window.removeEventListener('keydown', onKeydown));
           :manifest="manifest"
           :register-id="activeRegisterId"
           :edges="edges"
-          :partitive-relations="partitiveRelationsForSphere"
+          :partitive-relations="conceptPartitiveRelations"
+          :generic-relations="conceptGenericRelations"
           @navigate="onSphereNavigate"
         />
         <!-- Detail mode -->