@glossarist/concept-browser 0.7.78 → 0.7.81

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

@@ -0,0 +1,285 @@
+import { describe, it, expect } from 'vitest';
+import type { PartitiveRelationWire } 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 extractPartitiveRelations(
+  concept: { '@id': string; 'gl:partitiveRelations'?: any[] },
+  registerId: string,
+  uriBase: string,
+  urnMap: Map<string, string>,
+): PartitiveRelationWire[] {
+  const relations: PartitiveRelationWire[] = [];
+  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}`;
+  };
+
+  const resolvePlurality = (plurality: any) => {
+    if (!plurality) return null;
+    const isShared = plurality['gl:isShared'] ?? plurality.is_shared;
+    if (typeof isShared !== 'boolean') return null;
+    const isUncertain = plurality['gl:isUncertain'] ?? plurality.is_uncertain ?? false;
+    const sharedTypeRef = plurality['gl:sharedType'] ?? plurality.shared_type;
+    let sharedType = null;
+    if (sharedTypeRef) {
+      const s = sharedTypeRef['gl:source'] ?? sharedTypeRef.source;
+      const i = sharedTypeRef['gl:id'] ?? sharedTypeRef.id;
+      if (s && i) sharedType = `${s}:${i}`;
+    }
+    return { isShared, isUncertain, sharedType };
+  };
+
+  for (const rel of concept['gl:partitiveRelations'] || []) {
+    const comprehensive = resolveConceptUri(rel['gl:comprehensive']);
+    if (!comprehensive) continue;
+    const partitives = (rel['gl:hasPartitive'] || [])
+      .map((member: any) => {
+        const ref = member['gl:ref'] || member;
+        const uri = resolveConceptUri(ref);
+        if (!uri || uri === sourceUri) return null;
+        const certainty = member['gl:certainty'] || 'confirmed';
+        if (certainty !== 'confirmed' && certainty !== 'possible') {
+          throw new Error(
+            `Invalid partitive member certainty: "${certainty}". Allowed: confirmed, possible`,
+          );
+        }
+        return { uri, certainty };
+      })
+      .filter((p: any): p is { uri: string; certainty: 'confirmed' | 'possible' } => p !== null);
+    if (partitives.length === 0) continue;
+    const completeness = rel['gl:completeness'] || 'complete';
+    if (completeness !== 'complete' && completeness !== 'partial') {
+      throw new Error(
+        `Invalid partitive relation completeness: "${completeness}". Allowed: complete, partial`,
+      );
+    }
+    relations.push({
+      source: sourceUri,
+      comprehensive,
+      partitives,
+      completeness,
+      plurality: resolvePlurality(rel['gl:hasPlurality']) as PartitiveRelationWire['plurality'],
+      criterion: rel['gl:criterion'],
+      register: registerId,
+    });
+  }
+  return relations;
+}
+
+describe('extractPartitiveRelations', () => {
+  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 complete relation with two confirmed members', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.10' } },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.26' } },
+          ],
+          'gl:completeness': 'complete',
+          'gl:criterion': { eng: 'measurement result composition' },
+        },
+      ],
+    };
+
+    const result = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(result).toHaveLength(1);
+    expect(result[0].comprehensive).toBe(`${uriBase}/${registerId}/concept/2.9`);
+    expect(result[0].partitives).toEqual([
+      { uri: `${uriBase}/${registerId}/concept/2.10`, certainty: 'confirmed' },
+      { uri: `${uriBase}/${registerId}/concept/2.26`, certainty: 'confirmed' },
+    ]);
+    expect(result[0].completeness).toBe('complete');
+    expect(result[0].criterion).toEqual({ eng: 'measurement result composition' });
+  });
+
+  it('defaults completeness to complete when omitted', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.10' } },
+          ],
+        },
+      ],
+    };
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.completeness).toBe('complete');
+  });
+
+  it('preserves partial completeness', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+          ],
+          'gl:completeness': 'partial',
+        },
+      ],
+    };
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.completeness).toBe('partial');
+  });
+
+  it('resolves plurality block (isShared + sharedType)', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+          ],
+          'gl:hasPlurality': {
+            'gl:isShared': true,
+            'gl:isUncertain': false,
+            'gl:sharedType': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.99' },
+          },
+        },
+      ],
+    };
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.plurality).toEqual({
+      isShared: true,
+      isUncertain: false,
+      sharedType: 'urn:vim:pub:v:2:2012:1.99',
+    });
+  });
+
+  it('returns null plurality when isShared missing', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+          ],
+          'gl:hasPlurality': { 'gl:isUncertain': true },
+        },
+      ],
+    };
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.plurality).toBeNull();
+  });
+
+  it('preserves per-member certainty', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.5' }, 'gl:certainty': 'possible' },
+          ],
+        },
+      ],
+    };
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.partitives).toEqual([
+      { uri: `${uriBase}/${registerId}/concept/1.4`, certainty: 'confirmed' },
+      { uri: `${uriBase}/${registerId}/concept/1.5`, certainty: 'possible' },
+    ]);
+  });
+
+  it('throws on invalid completeness', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+          ],
+          'gl:completeness': 'closed',
+        },
+      ],
+    };
+    expect(() => extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*completeness.*closed/);
+  });
+
+  it('throws on invalid member certainty', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' }, 'gl:certainty': 'maybe' },
+          ],
+        },
+      ],
+    };
+    expect(() => extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*certainty.*maybe/);
+  });
+
+  it('skips a relation whose comprehensive cannot be resolved', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+          ],
+        },
+      ],
+    };
+    expect(extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toHaveLength(0);
+  });
+
+  it('skips a relation with no resolvable partitives', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          'gl:hasPartitive': [{ 'gl:ref': { 'gl:id': '1.4' } }],
+        },
+      ],
+    };
+    expect(extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toHaveLength(0);
+  });
+
+  it('excludes the source concept from partitives (self-loop guard)', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.10' } },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' } },
+          ],
+        },
+      ],
+    };
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.partitives).toHaveLength(1);
+    expect(rel.partitives[0].uri).toBe(`${uriBase}/${registerId}/concept/2.10`);
+  });
+
+  it('returns empty array when concept has no partitiveRelations', () => {
+    const concept = { '@id': sourceUri };
+    expect(extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toEqual([]);
+  });
+});

package/src/adapters/GraphDataSource.ts

@@ -1,4 +1,4 @@
-import type { GraphEdge, GraphNode, PartitiveHyperedge, SectionNode } from './types';
+import type { GraphEdge, GraphNode, PartitiveRelationWire, SectionNode } from './types';
 import type { Concept, RelatedConcept } from 'glossarist';
 import type { DatasetAdapter } from './DatasetAdapter';
 import { UriRouter } from './UriRouter';
@@ -30,6 +30,16 @@ function resolveRefTarget(rc: RelatedConcept, uriBase: string, registerId: strin
   return ref.source || '';
 }
 
+function contentLabel(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.default ?? obj.eng ?? Object.values(obj)[0];
+  }
+  return undefined;
+}
+
 export class GraphDataSource {
   constructor(private adapter: DatasetAdapter) {}
 
@@ -58,11 +68,11 @@ export class GraphDataSource {
     return data.edges ?? [];
   }
 
-  async loadHyperedges(): Promise<PartitiveHyperedge[]> {
-    const resp = await fetch(`${this.baseUrl}/hyperedges.json`);
+  async loadPartitiveRelations(): Promise<PartitiveRelationWire[]> {
+    const resp = await fetch(`${this.baseUrl}/partitive_relations.json`);
     if (!resp.ok) return [];
     const data = await resp.json();
-    return data.hyperedges ?? [];
+    return data.relations ?? data.hyperedges ?? [];
   }
 
   async loadGraphNodes(): Promise<{ uriPrefix: string; nodes: [string, Record<string, string>, string][] }> {
@@ -90,7 +100,7 @@ export class GraphDataSource {
           source: sourceUri,
           target,
           type: rc.type || 'references',
-          label: rc.content || undefined,
+          label: contentLabel(rc.content),
           register: parsed?.registerId ?? this.registerId,
         });
       }
@@ -107,7 +117,7 @@ export class GraphDataSource {
             source: sourceUri,
             target,
             type: rc.type || 'references',
-            label: rc.content || undefined,
+            label: contentLabel(rc.content),
             register: parsed?.registerId ?? this.registerId,
             lang,
           });

package/src/adapters/dataset-stats.ts

@@ -0,0 +1,13 @@
+/**
+ * Dataset-level stats shape. The data pipeline emits this as
+ * `public/data/{registerId}/stats.json`. Consumers fetch via HTTP.
+ *
+ * Kept in adapters/types.ts (the SSOT for wire shapes) so all views
+ * that need stats share the same definition.
+ */
+export interface DatasetStats {
+  sourceCount: number;
+  sources: Array<{ ref: string; types: string[]; conceptCount: number }>;
+  relationshipCount: number;
+  relationshipTypes: Record<string, number>;
+}

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

@@ -10,14 +10,15 @@
 // This file declares the runtime shape so consumer code can be type-checked.
 // DELETE this file when upstream ships proper declarations — tracked by
 // PR glossarist/glossarist-js#31 (targets v0.4.3+).
+//
+// v2 PartitiveRelation block (below) tracks glossarist 0.4.20 — the runtime
+// exports PartitiveRelation/PartitiveMember/TypeSharedPlurality from
+// src/models/index.js, but the d.ts has not been updated. Remove the v2
+// block when upstream PRs the d.ts changes.
 
 import type { ConceptSource, Citation, GlossaristModel } from 'glossarist';
 
 declare module 'glossarist' {
-  interface ConceptSource {
-    sourced_from?: Citation[];
-  }
-
   class RegistrableModel extends GlossaristModel {
     static register(type: string, cls: typeof RegistrableModel): void;
     static fromData(data: Record<string, unknown>): RegistrableModel;
@@ -134,4 +135,154 @@ declare module 'glossarist' {
     static fromYAML(yamlString: string): BibliographyData;
     static fromJSON(data: Record<string, unknown>): BibliographyData;
   }
+
+  // ── v2 PartitiveRelation (glossarist 0.4.20) ────────────────────────────
+  // Runtime exports these from src/models/index.js; d.ts is stale.
+
+  type Completeness = 'complete' | 'partial';
+  const COMPLETENESS: { readonly COMPLETE: 'complete'; readonly PARTIAL: 'partial' };
+  const COMPLETENESS_VALUES: readonly Completeness[];
+  const DEFAULT_COMPLETENESS: Completeness;
+  function isValidCompleteness(value: unknown): value is Completeness;
+
+  type MemberCertainty = 'confirmed' | 'possible';
+  const MEMBER_CERTAINTY: { readonly CONFIRMED: 'confirmed'; readonly POSSIBLE: 'possible' };
+  const MEMBER_CERTAINTY_VALUES: readonly MemberCertainty[];
+  const DEFAULT_MEMBER_CERTAINTY: MemberCertainty;
+  function isValidMemberCertainty(value: unknown): value is MemberCertainty;
+
+  class TypeSharedPlurality extends GlossaristModel {
+    constructor(data?: {
+      isShared?: boolean;
+      is_shared?: boolean;
+      isUncertain?: boolean;
+      is_uncertain?: boolean;
+      sharedType?: ConceptRef;
+      shared_type?: ConceptRef;
+    });
+    readonly isShared: boolean;
+    readonly isUncertain: boolean;
+    readonly sharedType: ConceptRef | null;
+    hasSharedType(): boolean;
+    toJSON(): { is_shared: boolean; is_uncertain?: boolean; shared_type?: ReturnType<ConceptRef['toJSON']> };
+    static fromJSON(data: Record<string, unknown>): TypeSharedPlurality;
+  }
+
+  class PartitiveMember extends GlossaristModel {
+    constructor(data?: { ref?: ConceptRef; certainty?: MemberCertainty });
+    readonly ref: ConceptRef;
+    readonly certainty: MemberCertainty;
+    readonly isConfirmed: boolean;
+    readonly isPossible: boolean;
+    toJSON(): { ref: ReturnType<ConceptRef['toJSON']>; certainty?: MemberCertainty };
+    static fromJSON(data: Record<string, unknown>): PartitiveMember;
+    static identityOf(value: unknown): string;
+  }
+
+  class PartitiveRelation extends GlossaristModel {
+    constructor(data?: {
+      comprehensive?: ConceptRef;
+      partitives?: PartitiveMember[];
+      completeness?: Completeness;
+      plurality?: TypeSharedPlurality;
+      criterion?: Record<string, string> | string;
+    });
+    readonly comprehensive: ConceptRef;
+    readonly partitives: PartitiveMember[];
+    readonly completeness: Completeness;
+    readonly plurality: TypeSharedPlurality | null;
+    readonly criterion: Record<string, string> | null;
+    readonly isComplete: boolean;
+    readonly isPartial: boolean;
+    readonly isCoordinate: boolean;
+    hasPlurality(): boolean;
+    hasCriterion(): boolean;
+    toJSON(): {
+      comprehensive: ReturnType<ConceptRef['toJSON']>;
+      partitives: ReturnType<PartitiveMember['toJSON']>[];
+      completeness: Completeness;
+      plurality?: ReturnType<TypeSharedPlurality['toJSON']>;
+      criterion?: Record<string, string>;
+    };
+    static fromJSON(data: Record<string, unknown>): PartitiveRelation;
+    static identityOf(value: unknown): string;
+  }
+
+  interface Concept {
+    readonly partitiveRelations: PartitiveRelation[];
+  }
+}
+
+// Re-declare the same exports under the 'glossarist/models' subpath so
+// deep-import callers can use them. Upstream's d.ts is stale on this
+// subpath too.
+declare module 'glossarist/models' {
+  export type Completeness = 'complete' | 'partial';
+  export const COMPLETENESS: { readonly COMPLETE: 'complete'; readonly PARTIAL: 'partial' };
+  export const COMPLETENESS_VALUES: readonly Completeness[];
+  export const DEFAULT_COMPLETENESS: Completeness;
+  export function isValidCompleteness(value: unknown): value is Completeness;
+
+  export type MemberCertainty = 'confirmed' | 'possible';
+  export const MEMBER_CERTAINTY: { readonly CONFIRMED: 'confirmed'; readonly POSSIBLE: 'possible' };
+  export const MEMBER_CERTAINTY_VALUES: readonly MemberCertainty[];
+  export const DEFAULT_MEMBER_CERTAINTY: MemberCertainty;
+  export function isValidMemberCertainty(value: unknown): value is MemberCertainty;
+
+  export class TypeSharedPlurality extends GlossaristModel {
+    constructor(data?: {
+      isShared?: boolean;
+      is_shared?: boolean;
+      isUncertain?: boolean;
+      is_uncertain?: boolean;
+      sharedType?: ConceptRef;
+      shared_type?: ConceptRef;
+    });
+    readonly isShared: boolean;
+    readonly isUncertain: boolean;
+    readonly sharedType: ConceptRef | null;
+    hasSharedType(): boolean;
+    toJSON(): { is_shared: boolean; is_uncertain?: boolean; shared_type?: ReturnType<ConceptRef['toJSON']> };
+    static fromJSON(data: Record<string, unknown>): TypeSharedPlurality;
+  }
+
+  export class PartitiveMember extends GlossaristModel {
+    constructor(data?: { ref?: ConceptRef; certainty?: MemberCertainty });
+    readonly ref: ConceptRef;
+    readonly certainty: MemberCertainty;
+    readonly isConfirmed: boolean;
+    readonly isPossible: boolean;
+    toJSON(): { ref: ReturnType<ConceptRef['toJSON']>; certainty?: MemberCertainty };
+    static fromJSON(data: Record<string, unknown>): PartitiveMember;
+    static identityOf(value: unknown): string;
+  }
+
+  export class PartitiveRelation extends GlossaristModel {
+    constructor(data?: {
+      comprehensive?: ConceptRef;
+      partitives?: PartitiveMember[];
+      completeness?: Completeness;
+      plurality?: TypeSharedPlurality;
+      criterion?: Record<string, string> | string;
+    });
+    readonly comprehensive: ConceptRef;
+    readonly partitives: PartitiveMember[];
+    readonly completeness: Completeness;
+    readonly plurality: TypeSharedPlurality | null;
+    readonly criterion: Record<string, string> | null;
+    readonly isComplete: boolean;
+    readonly isPartial: boolean;
+    readonly isCoordinate: boolean;
+    hasPlurality(): boolean;
+    hasCriterion(): boolean;
+    toJSON(): {
+      comprehensive: ReturnType<ConceptRef['toJSON']>;
+      partitives: ReturnType<PartitiveMember['toJSON']>[];
+      completeness: Completeness;
+      plurality?: ReturnType<TypeSharedPlurality['toJSON']>;
+      criterion?: Record<string, string>;
+    };
+    static fromJSON(data: Record<string, unknown>): PartitiveRelation;
+    static identityOf(value: unknown): string;
+  }
 }

package/src/adapters/types.ts

@@ -149,31 +149,41 @@ export interface GraphEdge {
 }
 
 /**
- * One-to-many partitive decomposition with optional plurality markers
- * and enumeration completeness (open vs closed).
+ * Wire-shape projection of a PartitiveRelation — used by:
+ *   - build-edges.js output (partitive_relations.json)
+ *   - GraphDataSource (loads the wire file for tools/future consumers)
+ *   - use-concept-edges composable (projects the glossarist-js model
+ *     into this shape for display, resolving ConceptRef → URI)
  *
- * Independent of {@link GraphEdge} (which stays binary). The UI renders
- * hyperedges specially (rake visualisation, enumeration/marker badges).
+ * The glossarist-js `PartitiveRelation` class is the model SSOT
+ * (ConceptRef-based). This interface is the *resolved-for-display*
+ * shape — keep the two concerns separate.
  *
- * See concept-model/TODO.hyperedge/00-design-overview.md.
+ * Renamed from `PartitiveRelation` to avoid collision with the
+ * upstream model class. v2 shape per concept-model
+ * TODO.partitive-relation-v2.
  */
-export interface PartitiveHyperedge {
-  /** URI of the concept that owns this hyperedge (the source). */
+export interface PartitiveRelationWire {
   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. */
+  partitives: PartitiveMemberWire[];
+  completeness: 'complete' | 'partial';
+  plurality: TypeSharedPluralityWire | null;
+  criterion?: Record<string, string>;
   register: string;
 }
 
+export interface PartitiveMemberWire {
+  uri: string;
+  certainty: 'confirmed' | 'possible';
+}
+
+export interface TypeSharedPluralityWire {
+  isShared: boolean;
+  isUncertain: boolean;
+  sharedType?: string | null;
+}
+
 export interface GraphNode {
   uri: string;
   register: string;