@glossarist/concept-browser 0.7.100 → 0.7.102

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

@@ -1,277 +0,0 @@
-/**
- * JSON-LD → Glossarist native mapping functions.
- *
- * Each mapper reads the wire-format JSON-LD (gl:-prefixed keys, see
- * src/adapters/wire-keys.ts for the SSOT) and emits the snake_case
- * dict that glossarist-js's Model.fromJSON constructors expect.
- *
- * Mappers are pure functions — no side effects, no global state.
- * Bridge machinery (WeakMaps) lives in bridges.ts.
- */
-import { GL } from '../wire-keys';
-import { DESIGNATION_REL_TYPES } from './bridges';
-import type {
-  JsonLdDesignation,
-  JsonLdRef,
-  JsonLdLocality,
-  JsonLdOrigin,
-  JsonLdSource,
-  JsonLdRelated,
-  JsonLdLocalizedConcept,
-  JsonLdConcept,
-} from './jsonld-types';
-
-export function isJsonLd(doc: Record<string, unknown>): boolean {
-  return '@type' in doc && GL.LOCALIZED_CONCEPT in doc;
-}
-
-export function mapDesignationFromJsonLd(d: JsonLdDesignation): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
-  const rawType = d['@type'] || '';
-
-  if (rawType.includes('Abbreviation')) result.type = 'abbreviation';
-  else if (rawType.includes('LetterSymbol')) result.type = 'letter_symbol';
-  else if (rawType.includes('GraphicalSymbol')) result.type = 'graphical_symbol';
-  else if (rawType.includes('Symbol')) result.type = 'symbol';
-  else result.type = 'expression';
-
-  result.designation = d[GL.TERM] ?? '';
-  result.normative_status = d[GL.NORMATIVE_STATUS] ?? null;
-
-  if (d[GL.ABSENT] != null) result.absent = d[GL.ABSENT];
-  if (d[GL.FIELD_OF_APPLICATION]) result.field_of_application = d[GL.FIELD_OF_APPLICATION];
-  if (d[GL.USAGE_INFO]) result.usage_info = d[GL.USAGE_INFO];
-  if (d[GL.GEOGRAPHICAL_AREA]) result.geographical_area = d[GL.GEOGRAPHICAL_AREA];
-  if (d[GL.LANGUAGE]) result.language = d[GL.LANGUAGE];
-  if (d[GL.SCRIPT]) result.script = d[GL.SCRIPT];
-  if (d[GL.SYSTEM]) result.system = d[GL.SYSTEM];
-  if (d[GL.INTERNATIONAL] != null) result.international = d[GL.INTERNATIONAL];
-  if (d[GL.TERM_TYPE]) result.term_type = d[GL.TERM_TYPE];
-
-  const pronunciation = d[GL.PRONUNCIATION];
-  if (pronunciation?.length) {
-    result.pronunciation = pronunciation.map(p => ({
-      content: p[GL.CONTENT] ?? null,
-      language: p[GL.LANGUAGE] ?? null,
-      script: p[GL.SCRIPT] ?? null,
-      system: p[GL.SYSTEM] ?? null,
-      country: p[GL.COUNTRY] ?? null,
-    }));
-  }
-
-  const sources = d[GL.SOURCE];
-  if (sources?.length) {
-    result.sources = sources.map(mapSourceFromJsonLd);
-  }
-
-  const related = d[GL.RELATED];
-  if (related?.length) {
-    result.related = related.map(r => {
-      const relType = r[GL.RELATIONSHIP_TYPE] ?? 'references';
-      if (DESIGNATION_REL_TYPES.has(relType) && r[GL.TARGET]) {
-        return { type: relType, target: r[GL.TARGET] };
-      }
-      return mapRelatedFromJsonLd(r);
-    });
-  }
-
-  if (d[GL.PREFIX] != null) result.prefix = d[GL.PREFIX];
-  if (d[GL.GENDER]) {
-    result.grammar_info = [{ gender: d[GL.GENDER] }];
-  }
-  const grammarInfo = d[GL.GRAMMAR_INFO];
-  if (grammarInfo?.length) {
-    result.grammar_info = grammarInfo.map(gi => ({
-      gender: gi[GL.GENDER] ?? null,
-      number: gi[GL.NUMBER] ?? null,
-      part_of_speech: gi[GL.PART_OF_SPEECH] ?? null,
-      noun: gi[GL.NOUN] ?? false,
-      verb: gi[GL.VERB] ?? false,
-      adj: gi[GL.ADJ] ?? false,
-      adverb: gi[GL.ADVERB] ?? false,
-      preposition: gi[GL.PREPOSITION] ?? false,
-      participle: gi[GL.PARTICIPLE] ?? false,
-    }));
-  }
-
-  return result;
-}
-
-export function mapRefFromJsonLd(rawRef: JsonLdRef | string | undefined): Record<string, unknown> | null {
-  if (!rawRef) return null;
-  if (typeof rawRef === 'string') return { source: rawRef };
-  const refObj: Record<string, unknown> = {};
-  // gl:-prefixed keys take precedence over unprefixed keys
-  refObj.source = rawRef[GL.SOURCE] ?? rawRef.source;
-  refObj.id = rawRef[GL.LOCAL_ID] ?? rawRef.id;
-  refObj.version = rawRef[GL.VERSION] ?? rawRef.version;
-  if (rawRef[GL.TEXT]) refObj.text = rawRef[GL.TEXT];
-  return (refObj.source ?? refObj.id ?? refObj.version ?? refObj.text) != null
-    ? refObj : null;
-}
-
-/**
- * Map JSON-LD locality to glossarist's snake_case format.
- * Always uses snake_case (reference_from/reference_to) for consistency
- * with the glossarist model.
- */
-export function mapLocalityFromJsonLd(rawLoc: JsonLdLocality | undefined): Record<string, unknown> | null {
-  if (!rawLoc) return null;
-  const locObj: Record<string, unknown> = {};
-  locObj.type = rawLoc[GL.LOCALITY_TYPE] ?? rawLoc.type;
-  locObj.reference_from = rawLoc[GL.REFERENCE_FROM] ?? rawLoc.reference_from;
-  locObj.reference_to = rawLoc[GL.REFERENCE_TO] ?? rawLoc.reference_to;
-  return (locObj.type ?? locObj.reference_from ?? locObj.reference_to) != null
-    ? locObj : null;
-}
-
-export function mapDetailedDefinitionFromJsonLd(d: any): Record<string, unknown> {
-  const result: Record<string, unknown> = { content: d[GL.CONTENT] ?? '' };
-  if (d[GL.EXAMPLES]?.length) {
-    result.examples = d[GL.EXAMPLES].map(mapDetailedDefinitionFromJsonLd);
-  }
-  return result;
-}
-
-export function mapOriginFromJsonLd(o: JsonLdOrigin): Record<string, unknown> {
-  const origin: Record<string, unknown> = {};
-  const ref = mapRefFromJsonLd(o[GL.REF]);
-  if (ref) origin.ref = ref;
-  const loc = mapLocalityFromJsonLd(o[GL.LOCALITY]);
-  if (loc) origin.locality = loc;
-  if (o[GL.LINK]) origin.link = o[GL.LINK];
-  if (o[GL.LOCAL_ID]) origin.id = o[GL.LOCAL_ID];
-  if (o[GL.VERSION]) origin.version = o[GL.VERSION];
-  if (o[GL.SOURCE]) origin.source = o[GL.SOURCE];
-  return origin;
-}
-
-export function mapSourceFromJsonLd(s: JsonLdSource): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
-  // JsonLdSource uses GL.LOCAL_ID ('gl:id') for the source's local id,
-  // distinct from JSON-LD's '@id' (the concept IRI).
-  if (s[GL.LOCAL_ID]) result.id = s[GL.LOCAL_ID];
-  if (s[GL.SOURCE_TYPE]) result.type = s[GL.SOURCE_TYPE];
-  if (s[GL.SOURCE_STATUS]) result.status = s[GL.SOURCE_STATUS];
-  if (s[GL.MODIFICATION]) result.modification = s[GL.MODIFICATION];
-
-  const origin = s[GL.ORIGIN];
-  if (origin) {
-    result.origin = mapOriginFromJsonLd(origin);
-  }
-
-  const sf = s[GL.SOURCED_FROM] ?? s[GL.SOURCED_FROM_ALT];
-  if (sf?.length) {
-    result.sourced_from = sf.map(item => mapOriginFromJsonLd(item));
-  }
-
-  return result;
-}
-
-export function mapRelatedFromJsonLd(r: JsonLdRelated): Record<string, unknown> {
-  const result: Record<string, unknown> = { type: 'references' };
-
-  if (r[GL.RELATIONSHIP_TYPE]) {
-    result.type = r[GL.RELATIONSHIP_TYPE];
-  }
-
-  if (r[GL.REF]) {
-    const ref = mapRefFromJsonLd(r[GL.REF]);
-    if (ref) result.ref = ref;
-  }
-
-  if (!result.ref && r['@id']) {
-    const uri = r['@id'];
-    const idMatch = uri.match(/\/concept\/([^/]+)$/);
-    result.ref = idMatch
-      ? { source: uri.split('/').slice(-3, -2)[0] || '', id: idMatch[1] }
-      : { source: uri, id: null };
-  }
-  if (r[GL.TERM]) result.content = r[GL.TERM];
-
-  // Bridged fields — stored in raw dict, extracted by attachBridges()
-  if (r[GL.SOURCE_ID]) result.sourceId = r[GL.SOURCE_ID];
-  const rawCitation = r[GL.CITATION];
-  if (rawCitation) {
-    const c = rawCitation;
-    const citation: Record<string, unknown> = {};
-    if (c[GL.REF]) {
-      const cr = mapRefFromJsonLd(c[GL.REF]);
-      if (cr) citation.ref = cr;
-    }
-    const loc = mapLocalityFromJsonLd(c[GL.LOCALITY]);
-    if (loc) citation.locality = loc;
-    if (c[GL.LINK]) citation.link = c[GL.LINK];
-    if (Object.keys(citation).length > 0) result.citation = citation;
-  }
-
-  return result;
-}
-
-export function mapLocalizedFromJsonLd(lc: JsonLdLocalizedConcept): Record<string, unknown> {
-  const data: Record<string, unknown> = {};
-
-  if (lc[GL.LANGUAGE_CODE]) data.language_code = lc[GL.LANGUAGE_CODE];
-  if (lc[GL.ENTRY_STATUS]) data.entry_status = lc[GL.ENTRY_STATUS];
-  if (lc[GL.CLASSIFICATION]) data.classification = lc[GL.CLASSIFICATION];
-  if (lc[GL.REVIEW_TYPE]) data.review_type = lc[GL.REVIEW_TYPE];
-  if (lc[GL.DOMAIN]) data.domain = lc[GL.DOMAIN];
-  if (lc[GL.RELEASE]) data.release = lc[GL.RELEASE];
-  if (lc[GL.LINEAGE_SOURCE_SIMILARITY] != null) data.lineage_source_similarity = lc[GL.LINEAGE_SOURCE_SIMILARITY];
-  if (lc[GL.SCRIPT]) data.script = lc[GL.SCRIPT];
-  if (lc[GL.SYSTEM]) data.system = lc[GL.SYSTEM];
-
-  const designation = lc[GL.DESIGNATION];
-  if (designation?.length) {
-    data.terms = designation.map(mapDesignationFromJsonLd);
-  }
-
-  const definition = lc[GL.DEFINITION];
-  if (definition?.length) {
-    data.definition = definition.map(mapDetailedDefinitionFromJsonLd);
-  }
-
-  const notes = lc[GL.NOTES];
-  if (notes?.length) {
-    data.notes = notes.map(mapDetailedDefinitionFromJsonLd);
-  }
-
-  const annotations = lc[GL.ANNOTATIONS];
-  if (annotations?.length) {
-    data.annotations = annotations.map(mapDetailedDefinitionFromJsonLd);
-  }
-
-  const examples = lc[GL.EXAMPLES];
-  if (examples?.length) {
-    data.examples = examples.map(mapDetailedDefinitionFromJsonLd);
-  }
-
-  const lcSources = lc[GL.SOURCE];
-  if (lcSources?.length) {
-    data.sources = lcSources.map(mapSourceFromJsonLd);
-  }
-
-  const dates = lc[GL.DATES];
-  if (dates?.length) {
-    data.dates = dates.map(d => ({
-      date: d[GL.DATE] ?? null,
-      type: d[GL.DATE_TYPE] ?? null,
-    }));
-  }
-
-  const lcReferences = lc[GL.REFERENCES];
-  if (lcReferences?.length) {
-    data.related = lcReferences.map(mapRelatedFromJsonLd);
-  }
-
-  if (lc[GL.REVIEW_DATE]) data.review_date = lc[GL.REVIEW_DATE];
-  if (lc[GL.REVIEW_DECISION_DATE]) data.review_decision_date = lc[GL.REVIEW_DECISION_DATE];
-  if (lc[GL.REVIEW_DECISION_EVENT]) data.review_decision_event = lc[GL.REVIEW_DECISION_EVENT];
-  if (lc[GL.REVIEW_STATUS]) data.review_status = lc[GL.REVIEW_STATUS];
-  if (lc[GL.REVIEW_DECISION]) data.review_decision = lc[GL.REVIEW_DECISION];
-  if (lc[GL.REVIEW_DECISION_NOTES]) data.review_decision_notes = lc[GL.REVIEW_DECISION_NOTES];
-
-  return data;
-}
-
-export type { JsonLdConcept };

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

@@ -1,79 +0,0 @@
-/**
- * Partitive relation mapping: JSON-LD → glossarist-js PartitiveRelation.
- *
- * Handles ISO 704:2022 MECE axes (presence × count) plus legacy
- * migration from the 5-value `multiplicity` enum and the 2-value
- * `certainty` field. See BRIDGES.md for the migration contract.
- */
-import { GL } from '../wire-keys';
-import { isPartitivePresence, isPartitiveCount } from '../../utils/partitive-multiplicity';
-import { mapRefFromJsonLd } from './mappers';
-import type { JsonLdPartitiveRelation } from './jsonld-types';
-
-export function mapPartitiveRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<string, unknown> | null {
-  const comprehensive = r[GL.COMPREHENSIVE] ? mapRefFromJsonLd(r[GL.COMPREHENSIVE]) : null;
-  if (!comprehensive) return null;
-
-  const partitives = (r[GL.HAS_PARTITIVE] ?? [])
-    .map((m): Record<string, unknown> | null => {
-      const ref = m[GL.REF] ? mapRefFromJsonLd(m[GL.REF]) : null;
-      if (!ref) return null;
-      const out: Record<string, unknown> = { ref };
-      // ISO 704:2022 MECE: prefer presence × count from JSON-LD. Fall back
-      // to migrating the legacy one-string `multiplicity` or v2 `certainty`
-      // so data in transit from older glossarist versions still loads.
-      const presence = m[GL.PRESENCE];
-      const count = m[GL.COUNT];
-      if (isPartitivePresence(presence) && isPartitiveCount(count)) {
-        out.presence = presence;
-        out.count = count;
-      } else {
-        const raw = m[GL.MULTIPLICITY] ?? splitLegacyCertainty(m[GL.CERTAINTY]);
-        if (raw) {
-          const parts = splitMultiplicity(raw);
-          out.presence = parts.presence;
-          out.count = parts.count;
-        }
-      }
-      if (m[GL.IS_DELIMITING] === true) out.is_delimiting = true;
-      return out;
-    })
-    .filter((m): m is Record<string, unknown> => m !== null);
-
-  // ISO 704 requires ≥2 partitives. Skip malformed relations rather
-  // than letting the constructor throw and break the whole concept.
-  if (partitives.length < 2) return null;
-
-  const out: Record<string, unknown> = {
-    comprehensive,
-    partitives,
-  };
-
-  if (r[GL.COMPLETENESS]) out.completeness = r[GL.COMPLETENESS];
-
-  if (r[GL.CRITERION]) {
-    out.criterion = typeof r[GL.CRITERION] === 'string'
-      ? { default: r[GL.CRITERION] }
-      : r[GL.CRITERION];
-  }
-
-  return out;
-}
-
-/** Migrate legacy v2 certainty → old v3 multiplicity string. */
-function splitLegacyCertainty(certainty: string | undefined): string | null {
-  if (!certainty) return null;
-  return certainty === 'possible' ? 'optional' : 'compulsory';
-}
-
-/** Split the legacy one-string multiplicity into MECE presence × count. */
-function splitMultiplicity(m: string): { presence: 'required' | 'optional'; count: 'exactly_one' | 'at_least_one' | 'multiple' } {
-  const LEGACY_MAP: Record<string, { presence: 'required' | 'optional'; count: 'exactly_one' | 'at_least_one' | 'multiple' }> = {
-    compulsory:               { presence: 'required', count: 'exactly_one' },
-    optional:                 { presence: 'optional', count: 'exactly_one' },
-    compulsory_multiple:      { presence: 'required', count: 'multiple' },
-    optional_multiple:        { presence: 'optional', count: 'multiple' },
-    compulsory_at_least_one:  { presence: 'required', count: 'at_least_one' },
-  };
-  return LEGACY_MAP[m] ?? { presence: 'required', count: 'exactly_one' };
-}

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

@@ -1,339 +0,0 @@
-// Local module augmentation for glossarist 0.4.26.
-//
-// Upstream's published src/models/index.d.ts declares ZERO classes for the
-// non-verbal hierarchy (Figure, Table, Formula, FigureImage, NonVerbalEntity,
-// SharedNonVerbalEntity, NonVerbalReference + subclasses, BibliographyEntry,
-// BibliographyData) plus the localized-string helpers. The top-level
-// index.d.ts re-exports the names, so TypeScript silently resolves every
-// consumer import to `any`.
-//
-// 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.
-//
-// v2 PartitiveRelation block (below) tracks glossarist 0.4.26 — the runtime
-// exports PartitiveRelation/PartitiveMember 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';
-import type { PartitivePresence, PartitiveCount } from '../../utils/partitive-multiplicity';
-
-declare module 'glossarist' {
-  class RegistrableModel extends GlossaristModel {
-    static register(type: string, cls: typeof RegistrableModel): void;
-    static fromData(data: Record<string, unknown>): RegistrableModel;
-  }
-
-  class FigureImage extends GlossaristModel {
-    constructor(data?: {
-      src?: string | null;
-      format?: string | null;
-      role?: string | null;
-      width?: number | null;
-      height?: number | null;
-      scale?: number | null;
-    });
-    readonly src: string | null;
-    readonly format: string | null;
-    readonly role: string | null;
-    readonly width: number | null;
-    readonly height: number | null;
-    readonly scale: number | null;
-    static fromJSON(data: Record<string, unknown>): FigureImage;
-  }
-
-  class NonVerbalEntity extends RegistrableModel {
-    constructor(data?: Record<string, unknown>);
-    readonly caption: Record<string, string> | null;
-    readonly description: Record<string, string> | null;
-    readonly alt: Record<string, string> | null;
-    readonly sources: ConceptSource[];
-    findById(targetId: string): NonVerbalEntity | null;
-    allIds(): string[];
-    static fromJSON(data: Record<string, unknown>): NonVerbalEntity;
-  }
-
-  class SharedNonVerbalEntity extends NonVerbalEntity {
-    constructor(data?: Record<string, unknown>);
-    readonly id: string | null;
-    readonly identifier: string | null;
-    findById(targetId: string): SharedNonVerbalEntity | null;
-    allIds(): string[];
-    static fromJSON(data: Record<string, unknown>): SharedNonVerbalEntity;
-  }
-
-  class Figure extends SharedNonVerbalEntity {
-    constructor(data?: Record<string, unknown>);
-    readonly images: FigureImage[];
-    readonly subfigures: Figure[];
-    findById(targetId: string): Figure | null;
-    allIds(): string[];
-    static fromJSON(data: Record<string, unknown>): Figure;
-  }
-
-  class Table extends SharedNonVerbalEntity {
-    constructor(data?: Record<string, unknown>);
-    readonly content: Record<string, unknown> | null;
-    readonly format: string | null;
-    static fromJSON(data: Record<string, unknown>): Table;
-  }
-
-  class Formula extends SharedNonVerbalEntity {
-    constructor(data?: Record<string, unknown>);
-    readonly expression: Record<string, string> | null;
-    readonly notation: string | null;
-    static fromJSON(data: Record<string, unknown>): Formula;
-  }
-
-  const NON_VERBAL_TYPES: readonly string[];
-
-  class NonVerbalReference extends RegistrableModel {
-    constructor(data?: Record<string, unknown>);
-    readonly entityId: string | null;
-    readonly display: string | null;
-    readonly dedupKey: readonly [string, string | null];
-    static fromJSON(data: Record<string, unknown> | string): NonVerbalReference;
-    static register(type: string, cls: typeof NonVerbalReference): void;
-  }
-
-  interface NonVerbRep {
-    readonly caption: string | null;
-    readonly description: string | null;
-    readonly alt: string | null;
-    readonly images: FigureImage[];
-  }
-
-  class FigureReference extends NonVerbalReference {
-    static fromJSON(data: Record<string, unknown> | string): FigureReference;
-  }
-
-  class TableReference extends NonVerbalReference {
-    static fromJSON(data: Record<string, unknown> | string): TableReference;
-  }
-
-  class FormulaReference extends NonVerbalReference {
-    static fromJSON(data: Record<string, unknown> | string): FormulaReference;
-  }
-
-  class BibliographyEntry extends GlossaristModel {
-    constructor(data?: Record<string, unknown>);
-    readonly id: string | null;
-    readonly reference: string | null;
-    readonly title: string | null;
-    readonly link: string | null;
-    readonly type: string | null;
-    static fromJSON(data: Record<string, unknown>): BibliographyEntry;
-  }
-
-  class BibliographyData extends GlossaristModel {
-    constructor(data?: Record<string, unknown>);
-    readonly entries: BibliographyEntry[];
-    find(id: string): BibliographyEntry | null;
-    readonly keys: string[];
-    toYAML(): string;
-    toJSON(): { bibliography: BibliographyEntry[] };
-    static fromYAML(yamlString: string): BibliographyData;
-    static fromJSON(data: Record<string, unknown>): BibliographyData;
-  }
-
-  // ── PartitiveRelation (glossarist 0.4.26 — MECE presence × count) ─
-  // Runtime exports these from src/models/index.js; d.ts is stale.
-  // (Tracked by PR glossarist/glossarist-js#31.)
-
-  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;
-
-  const PARTITIVE_PRESENCE: { readonly REQUIRED: 'required'; readonly OPTIONAL: 'optional' } & { readonly VALUES: readonly ['required', 'optional'] };
-  type PartitivePresence = (typeof PARTITIVE_PRESENCE.VALUES)[number];
-  const PARTITIVE_PRESENCE_VALUES: readonly PartitivePresence[];
-  const DEFAULT_PRESENCE: PartitivePresence;
-  function isValidPresence(value: unknown): value is PartitivePresence;
-
-  const PARTITIVE_COUNT: { readonly EXACTLY_ONE: 'exactly_one'; readonly AT_LEAST_ONE: 'at_least_one'; readonly MULTIPLE: 'multiple' } & { readonly VALUES: readonly ['exactly_one', 'at_least_one', 'multiple'] };
-  type PartitiveCount = (typeof PARTITIVE_COUNT.VALUES)[number];
-  const PARTITIVE_COUNT_VALUES: readonly PartitiveCount[];
-  const DEFAULT_COUNT: PartitiveCount;
-  function isValidCount(value: unknown): value is PartitiveCount;
-
-  type Multiplicity =
-    | 'compulsory' | 'optional' | 'compulsory_multiple'
-    | 'optional_multiple' | 'compulsory_at_least_one';
-  const MULTIPLICITY: Record<string, Multiplicity>;
-  const MULTIPLICITY_VALUES: readonly Multiplicity[];
-  const DEFAULT_MULTIPLICITY: Multiplicity;
-  function isValidMultiplicity(value: unknown): value is Multiplicity;
-  function multiplicityFromPair(presence: PartitivePresence, count: PartitiveCount): Multiplicity;
-  function pairFromMultiplicity(name: Multiplicity): { presence: PartitivePresence; count: PartitiveCount };
-
-  interface Concept {
-    readonly relations: AbstractHyperedge[];
-  }
-
-  // Re-exposed here so callers importing from the top-level `glossarist`
-  // entry get the MECE-augmented shape, not the stale d.ts type.
-  export class HyperedgeMember extends GlossaristModel {
-    constructor(data?: {
-      ref?: ConceptRef;
-      presence?: PartitivePresence;
-      count?: PartitiveCount;
-    });
-    readonly ref: ConceptRef;
-    readonly presence: PartitivePresence;
-    readonly count: PartitiveCount;
-    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 {
-    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;
-    readonly members: HyperedgeMember[];
-    readonly completeness: Completeness;
-    readonly criterion: Record<string, string> | null;
-    readonly sources: ConceptSource[];
-    readonly notes: Record<string, string> | null;
-    readonly status: string | null;
-    readonly isComplete: boolean;
-    readonly isPartial: boolean;
-    readonly isCoordinate: boolean;
-    toJSON(): Record<string, unknown>;
-    static fromJSON(data: Record<string, unknown>): AbstractHyperedge;
-    static identityOf(value: unknown): string;
-  }
-
-  export class PartitiveHyperedge extends AbstractHyperedge {
-    get partitives(): HyperedgeMember[];
-    static fromJSON(data: Record<string, unknown>): PartitiveHyperedge;
-    static identityOf(value: unknown): string;
-  }
-
-  export class GenericHyperedge extends AbstractHyperedge {
-    static fromJSON(data: Record<string, unknown>): GenericHyperedge;
-    static identityOf(value: unknown): string;
-  }
-
-  // Legacy aliases (deprecated — use Hyperedge-based names)
-  export class PartitiveRelation extends PartitiveHyperedge {}
-}
-
-// 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.
-//
-// The duplication between the 'glossarist' block above and this block
-// is forced by upstream's broken d.ts (PR glossarist/glossarist-js#31).
-// We cannot `export import` from a local namespace because TypeScript
-// requires `declare module` blocks to be self-contained. When upstream
-// ships proper d.ts, DELETE this entire file.
-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 const PARTITIVE_PRESENCE: { readonly REQUIRED: 'required'; readonly OPTIONAL: 'optional' } & { readonly VALUES: readonly ['required', 'optional'] };
-  export type PartitivePresence = (typeof PARTITIVE_PRESENCE.VALUES)[number];
-  export const PARTITIVE_PRESENCE_VALUES: readonly PartitivePresence[];
-  export const DEFAULT_PRESENCE: PartitivePresence;
-  export function isValidPresence(value: unknown): value is PartitivePresence;
-
-  export const PARTITIVE_COUNT: { readonly EXACTLY_ONE: 'exactly_one'; readonly AT_LEAST_ONE: 'at_least_one'; readonly MULTIPLE: 'multiple' } & { readonly VALUES: readonly ['exactly_one', 'at_least_one', 'multiple'] };
-  export type PartitiveCount = (typeof PARTITIVE_COUNT.VALUES)[number];
-  export const PARTITIVE_COUNT_VALUES: readonly PartitiveCount[];
-  export const DEFAULT_COUNT: PartitiveCount;
-  export function isValidCount(value: unknown): value is PartitiveCount;
-
-  export type Multiplicity =
-    | 'compulsory' | 'optional' | 'compulsory_multiple'
-    | 'optional_multiple' | 'compulsory_at_least_one';
-  export const MULTIPLICITY: Record<string, Multiplicity>;
-  export const MULTIPLICITY_VALUES: readonly Multiplicity[];
-  export const DEFAULT_MULTIPLICITY: Multiplicity;
-  export function isValidMultiplicity(value: unknown): value is Multiplicity;
-  export function multiplicityFromPair(presence: PartitivePresence, count: PartitiveCount): Multiplicity;
-  export function pairFromMultiplicity(name: Multiplicity): { presence: PartitivePresence; count: PartitiveCount };
-  // (TypeSharedPlurality removed — superseded by presence/count on
-  // PartitiveMember per MECE refactor. Was dead code.)
-
-  // ── Hyperedge classes (glossarist 0.4.33 — unified n-ary model) ─
-
-  export class HyperedgeMember extends GlossaristModel {
-    constructor(data?: {
-      ref?: ConceptRef;
-      presence?: PartitivePresence;
-      count?: PartitiveCount;
-      is_delimiting?: boolean;
-    });
-    readonly ref: ConceptRef;
-    readonly presence: PartitivePresence;
-    readonly count: PartitiveCount;
-    readonly is_delimiting: boolean;
-    required(): boolean;
-    optional(): boolean;
-    get isDelimiting(): 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 AbstractHyperedge extends GlossaristModel {
-    readonly comprehensive: ConceptRef;
-    readonly members: HyperedgeMember[];
-    readonly completeness: Completeness;
-    readonly criterion: Record<string, string> | null;
-    readonly sources: ConceptSource[];
-    readonly notes: Record<string, string> | null;
-    readonly status: string | null;
-    readonly isComplete: boolean;
-    readonly isPartial: boolean;
-    readonly isCoordinate: boolean;
-    toJSON(): Record<string, unknown>;
-    static fromJSON(data: Record<string, unknown>): AbstractHyperedge;
-    static identityOf(value: unknown): string;
-  }
-
-  export class PartitiveHyperedge extends AbstractHyperedge {
-    get partitives(): HyperedgeMember[];
-    static fromJSON(data: Record<string, unknown>): PartitiveHyperedge;
-    static identityOf(value: unknown): string;
-  }
-
-  export class GenericHyperedge extends AbstractHyperedge {
-    static fromJSON(data: Record<string, unknown>): GenericHyperedge;
-    static identityOf(value: unknown): string;
-  }
-
-  // Legacy aliases (deprecated)
-  export class PartitiveRelation extends PartitiveHyperedge {}
-}