@glossarist/concept-browser 0.7.92 → 0.7.94

package/package.json

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

package/src/__tests__/__fixtures__/concepts.ts

@@ -204,6 +204,35 @@ 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',
+      },
+    ],
+  });
+}
+
 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 +241,7 @@ 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() },
 ];
 
 export function fixtureByName(name: string): ConceptFixture {

package/src/__tests__/components/GenericRelationList.test.ts

@@ -58,8 +58,8 @@ function makeRelation(overrides: Partial<GenericRelationWire> = {}): GenericRela
     source: 'https://example.org/test/concept/5-1',
     comprehensive: 'https://example.org/test/concept/5-1',
     members: [
-      { uri: 'https://example.org/test/concept/5-4', presence: 'required', count: 'exactly_one', isDelimiting: false },
-      { uri: 'https://example.org/test/concept/5-5', presence: 'required', count: 'exactly_one', isDelimiting: false },
+      { uri: 'https://example.org/test/concept/5-4', presence: 'required', count: 'exactly_one', delimitingCharacteristic: { eng: "test characteristic" } },
+      { uri: 'https://example.org/test/concept/5-5', presence: 'required', count: 'exactly_one', delimitingCharacteristic: { eng: "test characteristic" } },
     ],
     completeness: 'complete',
     register: 'test',
@@ -120,8 +120,8 @@ describe('GenericRelationList — wire-type contract mount test', () => {
       props: {
         relations: [makeRelation({
           members: [
-            { uri: 'https://example.org/test/concept/5-4', presence: 'optional', count: 'multiple', isDelimiting: true },
-            { uri: 'https://example.org/test/concept/5-5', presence: 'required', count: 'exactly_one', isDelimiting: false },
+            { uri: 'https://example.org/test/concept/5-4', presence: 'optional', count: 'multiple', delimitingCharacteristic: { eng: "delimiting by light sensors" } },
+            { uri: 'https://example.org/test/concept/5-5', presence: 'required', count: 'exactly_one', delimitingCharacteristic: { eng: "test characteristic" } },
           ],
         })],
         manifest,

package/src/__tests__/components/GenericRelationList.test.ts.bak

@@ -0,0 +1,147 @@
+/**
+ * GenericRelationList mount test — pins the wire-type contract so
+ * the 5 type bugs found in audit (entry.titles, member.ref,
+ * is_delimiting casing, comprehensive.source, missing props)
+ * can't regress.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { mount } from '@vue/test-utils';
+import GenericRelationList from '../../components/GenericRelationList.vue';
+import type { GenericRelationWire } from '../../adapters/types';
+
+// Stub the composables the component depends on
+vi.mock('../../stores/vocabulary', () => ({
+  useVocabularyStore: () => ({
+    graph: { getNode: () => null },
+    datasets: new Map(),
+  }),
+}));
+
+vi.mock('../../adapters/factory', () => ({
+  getFactory: () => ({
+    resolve: (uri: string) => ({ type: 'unresolved' as const, uri }),
+  }),
+}));
+
+vi.mock('../../i18n', () => ({
+  useI18n: () => ({ t: (key: string) => key }),
+  locale: { value: 'eng' },
+}));
+
+vi.mock('vue-router', () => ({
+  useRouter: () => ({ push: vi.fn() }),
+}));
+
+const manifest = {
+  id: 'test',
+  datasetUri: 'https://example.org/test',
+  title: 'Test',
+  description: '',
+  owner: '',
+  baseUrl: '',
+  languages: ['eng'],
+  conceptCount: 0,
+  conceptUrlTemplate: '',
+  indexUrl: '',
+  contextUrl: '',
+  uriBase: 'https://example.org',
+  status: 'valid',
+  schemaVersion: '3',
+  tags: [],
+  lastUpdated: '',
+  sourceRepo: '',
+  chunkSize: 100,
+} as any;
+
+function makeRelation(overrides: Partial<GenericRelationWire> = {}): GenericRelationWire {
+  return {
+    source: 'https://example.org/test/concept/5-1',
+    comprehensive: 'https://example.org/test/concept/5-1',
+    members: [
+      { uri: 'https://example.org/test/concept/5-4', presence: 'required', count: 'exactly_one', isDelimiting: false },
+      { uri: 'https://example.org/test/concept/5-5', presence: 'required', count: 'exactly_one', isDelimiting: false },
+    ],
+    completeness: 'complete',
+    register: 'test',
+    ...overrides,
+  };
+}
+
+describe('GenericRelationList — wire-type contract mount test', () => {
+  it('mounts without errors for a well-formed relation', () => {
+    const w = mount(GenericRelationList, {
+      props: {
+        relations: [makeRelation()],
+        manifest,
+        registerId: 'test',
+      },
+    });
+    expect(w.html()).toContain('generic-relation-card');
+  });
+
+  it('renders completeness badge', () => {
+    const w = mount(GenericRelationList, {
+      props: {
+        relations: [makeRelation({ completeness: 'partial' })],
+        manifest,
+        registerId: 'test',
+      },
+    });
+    expect(w.html()).toContain('completeness-partial');
+  });
+
+  it('renders multiple relations', () => {
+    const w = mount(GenericRelationList, {
+      props: {
+        relations: [
+          makeRelation({ comprehensive: 'https://example.org/test/concept/5-1' }),
+          makeRelation({ comprehensive: 'https://example.org/test/concept/5-2' }),
+        ],
+        manifest,
+        registerId: 'test',
+      },
+    });
+    expect(w.findAll('.generic-relation-card')).toHaveLength(2);
+  });
+
+  it('renders criterion when present', () => {
+    const w = mount(GenericRelationList, {
+      props: {
+        relations: [makeRelation({ criterion: { eng: 'by realization medium' } })],
+        manifest,
+        registerId: 'test',
+      },
+    });
+    expect(w.html()).toContain('by realization medium');
+  });
+
+  it('renders member presence/count badges for non-default values', () => {
+    const w = mount(GenericRelationList, {
+      props: {
+        relations: [makeRelation({
+          members: [
+            { uri: 'https://example.org/test/concept/5-4', presence: 'optional', count: 'multiple', isDelimiting: true },
+            { uri: 'https://example.org/test/concept/5-5', presence: 'required', count: 'exactly_one', isDelimiting: false },
+          ],
+        })],
+        manifest,
+        registerId: 'test',
+      },
+    });
+    const html = w.html();
+    expect(html).toContain('Optional');
+    expect(html).toContain('Multiple');
+  });
+
+  it('renders empty section when relations array is empty', () => {
+    const w = mount(GenericRelationList, {
+      props: {
+        relations: [],
+        manifest,
+        registerId: 'test',
+      },
+    });
+    expect(w.find('section.generic-relations').exists()).toBe(true);
+    expect(w.findAll('.generic-relation-card')).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,115 @@
+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);
+  });
+});

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 PartitiveMemberModel.fromJSON(data as unknown as Record<string, unknown>) 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 PartitiveHyperedgeModel.fromJSON(opts as unknown as Record<string, unknown>) as PartitiveHyperedge;
+  return new (PartitiveHyperedgeModel as unknown as new (data: unknown) => PartitiveHyperedge)(opts) as PartitiveHyperedge;
 }
 
 describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () => {
@@ -84,14 +84,14 @@ describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () =>
 
     it('is_delimiting defaults to false', () => {
       const m = makePartitive('test', '1.1');
-      expect(m.is_delimiting).toBe(false);
-      expect(m.is_delimiting).toBe(false);
+      expect((m as any).is_delimiting).toBe(false);
+      expect((m as any).is_delimiting).toBe(false);
     });
 
     it('is_delimiting is preserved when set to true', () => {
       const m = makePartitive('test', '1.1', { isDelimiting: true });
-      expect(m.is_delimiting).toBe(true);
-      expect(m.is_delimiting).toBe(true);
+      expect((m as any).is_delimiting).toBe(true);
+      expect((m as any).is_delimiting).toBe(true);
     });
 
     it('rejects the vacuous (presence=optional, count=at_least_one)', () => {

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

@@ -84,14 +84,14 @@ describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () =>
 
     it('is_delimiting defaults to false', () => {
       const m = makePartitive('test', '1.1');
-      expect(m.is_delimiting).toBe(false);
-      expect(m.is_delimiting).toBe(false);
+      expect((m as any).is_delimiting).toBe(false);
+      expect((m as any).is_delimiting).toBe(false);
     });
 
     it('is_delimiting is preserved when set to true', () => {
       const m = makePartitive('test', '1.1', { isDelimiting: true });
-      expect(m.is_delimiting).toBe(true);
-      expect(m.is_delimiting).toBe(true);
+      expect((m as any).is_delimiting).toBe(true);
+      expect((m as any).is_delimiting).toBe(true);
     });
 
     it('rejects the vacuous (presence=optional, count=at_least_one)', () => {
@@ -107,7 +107,7 @@ describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () =>
         comprehensive: makeRef('test', '1.3'),
         partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
       });
-      expect(r.members).toHaveLength(2);
+      expect((r as any).members).toHaveLength(2);
       expect((r as any).completeness).toBe('complete');
       expect((r as any).isComplete).toBe(true);
       expect((r as any).isPartial).toBe(false);

package/src/__tests__/wire-keys.test.ts

@@ -60,6 +60,6 @@ describe('GL wire-key SSOT', () => {
     // The point of this test: when adding a key, you remember to update
     // the count; when removing, you notice the test fails. Catches
     // accidental drift in either direction.
-    expect(Object.keys(GL).length).toBe(90);
+    expect(Object.keys(GL).length).toBe(91);
   });
 });

package/src/__tests__/wire-keys.test.ts.bak

@@ -0,0 +1,65 @@
+/**
+ * Wire-key SSOT contract.
+ *
+ * Audit-driven (AUDIT-2026-07-29 P1-3).
+ *
+ * The GL record is the single source of truth for the JSON-LD wire-format
+ * keys used across src/adapters/. This spec pins:
+ *
+ *   - Every entry is a string starting with 'gl:' (or '@' for JSON-LD core)
+ *   - No two entries share the same value (injectivity — one key, one name)
+ *   - The set of values matches what's declared in jsonld-types.ts
+ *     (catches drift if someone adds a key to one but not the other)
+ */
+import { describe, it, expect } from 'vitest';
+import { GL } from '../adapters/wire-keys';
+
+describe('GL wire-key SSOT', () => {
+  it('every value is a non-empty string', () => {
+    for (const value of Object.values(GL)) {
+      expect(typeof value).toBe('string');
+      expect(value.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('every value starts with gl: or @ (JSON-LD namespace)', () => {
+    for (const value of Object.values(GL)) {
+      expect(value.startsWith('gl:') || value.startsWith('@')).toBe(true);
+    }
+  });
+
+  it('no two entries share the same value (injectivity)', () => {
+    const values = Object.values(GL);
+    expect(new Set(values).size).toBe(values.length);
+  });
+
+  it('MECE keys are present (presence, count, isDelimiting, multiplicity, certainty)', () => {
+    expect(GL.PRESENCE).toBe('gl:presence');
+    expect(GL.COUNT).toBe('gl:count');
+    expect(GL.IS_DELIMITING).toBe('gl:isDelimiting');
+    expect(GL.MULTIPLICITY).toBe('gl:multiplicity');
+    expect(GL.CERTAINTY).toBe('gl:certainty');
+  });
+
+  it('JSON-LD core keys are present', () => {
+    expect(GL.ID).toBe('@id');
+    expect(GL.TYPE).toBe('@type');
+  });
+
+  it('LOCAL_ID is distinct from ID (one is gl:id, the other @id)', () => {
+    // Both represent "id" but in different namespaces:
+    //   GL.ID (@id)        — JSON-LD IRI for the concept
+    //   GL.LOCAL_ID (gl:id) — source-local id within ConceptSource/Origin/Ref
+    expect(GL.ID).toBe('@id');
+    expect(GL.LOCAL_ID).toBe('gl:id');
+    expect(GL.ID).not.toBe(GL.LOCAL_ID);
+  });
+
+  it('count matches documented set (no drift)', () => {
+    // Update this number when adding a new key.
+    // The point of this test: when adding a key, you remember to update
+    // the count; when removing, you notice the test fails. Catches
+    // accidental drift in either direction.
+    expect(Object.keys(GL).length).toBe(90);
+  });
+});

package/src/adapters/model-bridge/hyperedge.ts

@@ -53,6 +53,15 @@ export function mapHyperedgeFromJsonLd(
         }
       }
       if (m[GL.IS_DELIMITING] === true) out.is_delimiting = true;
+      // ISO 704:2022 §5.5.4.2.1 — GenericMember carries a required
+      // delimitingCharacteristic (the intension difference between
+      // this specific concept and its coordinate concepts).
+      const dc = m[GL.DELIMITING_CHARACTERISTIC];
+      if (dc) {
+        out.delimitingCharacteristic = typeof dc === 'string'
+          ? { default: dc }
+          : dc;
+      }
       return out;
     })
     .filter((m): m is Record<string, unknown> => m !== null);

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`
@@ -182,22 +180,37 @@ declare module 'glossarist' {
       ref?: ConceptRef;
       presence?: PartitivePresence;
       count?: PartitiveCount;
-      is_delimiting?: boolean;
     });
     readonly ref: ConceptRef;
     readonly presence: PartitivePresence;
     readonly count: PartitiveCount;
-    readonly is_delimiting: boolean;
-    readonly isRequired: boolean;
-    readonly isOptional: boolean;
-    get isDelimiting(): boolean;
+    required(): boolean;
+    optional(): boolean;
     toJSON(): Record<string, unknown>;
     static fromJSON(data: Record<string, unknown>): HyperedgeMember;
     static identityOf(value: unknown): string;
   }
 
-  export class PartitiveMember extends HyperedgeMember {}
-  export class GenericMember extends HyperedgeMember {}
+  export class PartitiveMember extends HyperedgeMember {
+    constructor(data?: {
+      ref?: ConceptRef;
+      presence?: PartitivePresence;
+      count?: PartitiveCount;
+      is_delimiting?: boolean;
+    });
+    readonly is_delimiting: boolean;
+    get isDelimiting(): boolean;
+  }
+
+  export class GenericMember extends HyperedgeMember {
+    constructor(data?: {
+      ref?: ConceptRef;
+      presence?: PartitivePresence;
+      count?: PartitiveCount;
+      delimitingCharacteristic?: Record<string, string> | string;
+    });
+    readonly delimitingCharacteristic: Record<string, string>;
+  }
 
   export class AbstractHyperedge extends GlossaristModel {
     readonly comprehensive: ConceptRef;

package/src/adapters/types.ts

@@ -200,7 +200,10 @@ export interface GenericMemberWire {
   uri: string;
   presence: 'required' | 'optional';
   count: 'exactly_one' | 'at_least_one' | 'multiple';
-  isDelimiting: boolean;
+  /** ISO 704:2022 §5.5.4.2.1 — the delimiting characteristic that
+   * distinguishes this specific concept from its coordinate concepts.
+   * Required on every GenericMember. LocalizedString shape. */
+  delimitingCharacteristic: Record<string, string>;
 }
 
 export interface GraphNode {

package/src/adapters/wire-keys.ts

@@ -134,6 +134,7 @@ export const GL = {
   PRESENCE: 'gl:presence',
   COUNT: 'gl:count',
   IS_DELIMITING: 'gl:isDelimiting',
+  DELIMITING_CHARACTERISTIC: 'gl:delimitingCharacteristic',
   MULTIPLICITY: 'gl:multiplicity',
   CERTAINTY: 'gl:certainty',
 

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

@@ -42,12 +42,17 @@ function designationFor(uri: string): string {
   return resolveDesignation(uri, store, factory, locale.value);
 }
 
+/** Resolve a LocalizedString delimitingCharacteristic to the current locale. */
+function characteristicText(dc: Record<string, string>): string {
+  return dc[locale.value] ?? dc.default ?? dc.eng ?? Object.values(dc)[0] ?? '';
+}
+
 function memberLabel(member: GenericRelationWire['members'][number]): PartitiveMemberLabeled {
   return {
     uri: member.uri,
     presence: member.presence,
     count: member.count,
-    isDelimiting: member.isDelimiting,
+    isDelimiting: false,
     label: designationFor(member.uri),
   };
 }
@@ -78,12 +83,15 @@ function memberLabel(member: GenericRelationWire['members'][number]): PartitiveM
         :completeness="rel.completeness"
       />
 
-      <ul class="member-presence-list" aria-label="Member presence and count">
+      <ul class="member-presence-list" aria-label="Member delimiting characteristics">
         <li v-for="(m, j) in rel.members" :key="j">
           <span class="member-label">{{ designationFor(m.uri) }}</span>
+          <span
+            v-if="m.delimitingCharacteristic"
+            class="member-delimiting-characteristic"
+          >{{ characteristicText(m.delimitingCharacteristic) }}</span>
           <span v-if="m.presence && m.presence !== 'required'" class="member-presence">{{ presenceLabel(m.presence) }}</span>
           <span v-if="m.count && m.count !== 'exactly_one'" class="member-count">{{ countLabel(m.count) }}</span>
-          <span v-if="m.isDelimiting" class="member-delimiting">{{ t('relations.delimiting') }}</span>
         </li>
       </ul>
     </div>

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,20 +176,27 @@ 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 members: PartitiveMemberWire[] = (rel.members ?? rel.partitives ?? [])
-      .map((m: any): PartitiveMemberWire | null => {
+    const isGeneric = rel instanceof GenericHyperedge;
+    const members: any[] = (rel.members ?? rel.partitives ?? [])
+      .map((m: any): any | null => {
         const uri = resolveConceptRefUri(m.ref);
         if (!uri || uri === source) return null;
-        return {
+        const base: any = {
           uri,
           presence: readPresence(m),
           count: readCount(m),
-          isDelimiting: readIsDelimiting(m),
         };
+        if (isGeneric) {
+          base.delimitingCharacteristic = m.delimitingCharacteristic;
+        } else {
+          base.isDelimiting = readIsDelimiting(m);
+        }
+        return base;
       })
-      .filter((m: PartitiveMemberWire | null): m is PartitiveMemberWire => m !== null);
+      .filter((m: any | null): m is any => m !== null);
     if (members.length === 0) return null;
     return {
       source,
@@ -196,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/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.isDelimiting;
-        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 } = useConceptEdges(
+  concept,
+  activeRegisterId,
+  manifest,
+  edges,
+  router,
+);
 const viewMode = ref<'detail' | 'sphere'>(
   router.currentRoute.value.query.view === 'sphere' ? 'sphere' : 'detail'
 );
@@ -326,7 +288,7 @@ onUnmounted(() => window.removeEventListener('keydown', onKeydown));
           :manifest="manifest"
           :register-id="activeRegisterId"
           :edges="edges"
-          :partitive-relations="partitiveRelationsForSphere"
+          :partitive-relations="conceptPartitiveRelations"
           @navigate="onSphereNavigate"
         />
         <!-- Detail mode -->