glossarist 0.4.19 → 0.4.22

package/src/models/index.d.ts

@@ -100,6 +100,7 @@ export class Concept extends GlossaristModel {
   readonly localizations: Record<string, any>;
   readonly raw: Record<string, unknown> | null;
   readonly relatedConcepts: RelatedConcept[];
+  readonly partitiveHyperedges: PartitiveHyperedge[];
   readonly domains: ConceptReference[];
   readonly tags: string[];
   readonly dates: ConceptDate[];
@@ -257,6 +258,8 @@ export class ConceptSource extends GlossaristModel {
   readonly type: string | null;
   readonly origin: Citation | null;
   readonly modification: string | null;
+  readonly sourcedFrom: Citation[];
+  /** @deprecated use sourcedFrom */
   readonly sourced_from: Citation[];
 }
 
@@ -267,6 +270,64 @@ export class RelatedConcept extends GlossaristModel {
   readonly ref: ConceptRef | null;
 }
 
+export interface LocalizedContent {
+  readonly [language: string]: string;
+}
+
+export const PARTITIVE_ENUMERATION: Readonly<{
+  readonly CLOSED: 'closed';
+  readonly OPEN: 'open';
+}>;
+export const PARTITIVE_ENUMERATION_VALUES: readonly ['closed', 'open'];
+export function isValidPartitiveEnumeration(value: unknown): value is 'closed' | 'open';
+
+export const PLURALITY_MARKER: Readonly<{
+  readonly DOUBLE: 'double';
+  readonly DASHED: 'dashed';
+}>;
+export const PLURALITY_MARKER_VALUES: readonly ['double', 'dashed'];
+export function isValidPluralityMarker(value: unknown): value is 'double' | 'dashed';
+
+export function makeEnum<T extends string>(
+  name: string,
+  values: Record<string, T>,
+): Readonly<Record<string, T>> & {
+  readonly name: string;
+  readonly VALUES: readonly T[];
+  readonly isValid: (value: unknown) => value is T;
+};
+
+export interface HyperedgeColorPair {
+  readonly light: string;
+  readonly dark: string;
+  readonly pattern: 'dashed' | 'double' | null;
+}
+
+export function resolveHyperedgeColor(
+  hyperedge: { enumeration?: string; markers?: string[] } | null,
+  options?: {
+    category?: string;
+    overrides?: { byCategory?: Record<string, unknown> };
+  },
+): HyperedgeColorPair | null;
+
+export class PartitiveHyperedge extends GlossaristModel {
+  readonly comprehensive: ConceptRef;
+  readonly parts: ConceptRef[];
+  readonly enumeration: 'closed' | 'open';
+  readonly markers: ('double' | 'dashed')[];
+  readonly content: LocalizedContent | null;
+
+  readonly isMarked: boolean;
+  readonly contentString: string | null;
+
+  hasMarker(value: string): boolean;
+  hasEnumeration(value: string): boolean;
+  identity(): string;
+  toJSON(): Record<string, unknown>;
+  static fromJSON(data: Record<string, unknown>): PartitiveHyperedge;
+}
+
 export const DESIGNATION_RELATIONSHIP_TYPES: readonly string[];
 export class DesignationRelationship extends GlossaristModel {
   readonly type: string | null;

package/src/models/index.js

@@ -21,6 +21,44 @@ export { Citation } from './citation.js';
 export { ConceptRef } from './concept-ref.js';
 export { ConceptSource } from './concept-source.js';
 export { RelatedConcept, RELATIONSHIP_TYPES } from './related-concept.js';
+export { PartitiveHyperedge } from './partitive-hyperedge.js';
+export {
+  PARTITIVE_ENUMERATION,
+  PARTITIVE_ENUMERATION_VALUES,
+  isValidPartitiveEnumeration,
+} from './partitive-enumeration.js';
+export {
+  PLURALITY_MARKER,
+  PLURALITY_MARKER_VALUES,
+  isValidPluralityMarker,
+} from './plurality-marker.js';
+
+// v2 PartitiveRelation models (TODO.partitive-relation-v2). These
+// supersede the v1 hyperedge models above; the v1 models are kept for
+// backward-compat input. New code should use v2 exclusively.
+export { PartitiveRelation } from './partitive-relation.js';
+export { PartitiveMember } from './partitive-member.js';
+export {
+  COMPLETENESS,
+  COMPLETENESS_VALUES,
+  DEFAULT_COMPLETENESS,
+  isValidCompleteness,
+} from './completeness.js';
+export {
+  MULTIPLICITY,
+  MULTIPLICITY_VALUES,
+  DEFAULT_MULTIPLICITY,
+  isValidMultiplicity,
+} from './multiplicity.js';
+
+// v1 → v2 migration helper. Pure function; idempotent.
+export {
+  migrateHyperedgeToRelation,
+  downgradeRelationToHyperedge,
+} from '../migration/partitive-relation-migrator.js';
+
+export { makeEnum } from './enum.js';
+export { resolveHyperedgeColor } from './hyperedge-colors.js';
 export { DesignationRelationship, DESIGNATION_RELATIONSHIP_TYPES } from './designation-relationship.js';
 export { ConceptReference } from './concept-reference.js';
 export { ConceptDate, DATE_TYPES } from './concept-date.js';

package/src/models/localized-concept.js

@@ -10,7 +10,36 @@ function wrapAs(Cls) {
   return item => item instanceof Cls ? item : new Cls(item);
 }
 
+const LOC_WIRE_NAMES = Object.freeze({
+  entryStatus: 'entry_status',
+  reviewType: 'review_type',
+  lineageSourceSimilarity: 'lineage_source_similarity',
+  reviewDate: 'review_date',
+  reviewDecisionDate: 'review_decision_date',
+  reviewDecisionEvent: 'review_decision_event',
+  reviewStatus: 'review_status',
+  reviewDecision: 'review_decision',
+  reviewDecisionNotes: 'review_decision_notes',
+});
+
 export class LocalizedConcept extends GlossaristModel {
+  // Scalar metadata fields the diff layer tracks per localization.
+  // Adding a new scalar field requires only appending its name here;
+  // diff/patch/similarity pick it up automatically.
+  // (Invariant N2 — TODO.hyperedges-v2/07.)
+  static get DIFF_FIELDS() {
+    return Object.freeze([
+      'entryStatus', 'classification', 'reviewType', 'domain', 'release',
+      'lineageSourceSimilarity', 'script', 'system',
+      'reviewDate', 'reviewDecisionDate', 'reviewDecisionEvent',
+      'reviewStatus', 'reviewDecision', 'reviewDecisionNotes',
+    ]);
+  }
+
+  static wireNameFor(field) {
+    return LOC_WIRE_NAMES[field] ?? field;
+  }
+
   constructor(data = {}) {
     super();
     this.languageCode = data.language_code ?? data.languageCode ?? null;

package/src/models/multiplicity.js

@@ -0,0 +1,24 @@
+// Multiplicity — ISO 704:2022 partitive member multiplicity.
+//
+// Encodes the diagram line notation as structured data:
+//   compulsory          — 1 solid line (must exist in every instance)
+//   optional            — 1 dashed line (exists in some instances only)
+//   compulsory_multiple — 2 solid lines (multiple must exist)
+//   optional_multiple   — 2 dashed lines (multiple may exist)
+//   at_least_one        — 1 solid + 1 dashed line (at least one must exist)
+//
+// Defaults to `compulsory` when omitted.
+
+import { makeEnum } from './enum.js';
+
+export const MULTIPLICITY = makeEnum('MULTIPLICITY', {
+  COMPULSORY: 'compulsory',
+  OPTIONAL: 'optional',
+  COMPULSORY_MULTIPLE: 'compulsory_multiple',
+  OPTIONAL_MULTIPLE: 'optional_multiple',
+  AT_LEAST_ONE: 'at_least_one',
+});
+
+export const MULTIPLICITY_VALUES = MULTIPLICITY.VALUES;
+export const DEFAULT_MULTIPLICITY = MULTIPLICITY.COMPULSORY;
+export const isValidMultiplicity = MULTIPLICITY.isValid;

package/src/models/partitive-enumeration.js

@@ -0,0 +1,23 @@
+// PartitiveEnumeration — allowed values for PartitiveHyperedge#enumeration.
+//
+//   closed — the encoded parts are ALL the parts of the comprehensive.
+//            Adding or removing a part would change the relationship.
+//   open   — the encoded parts are SOME of the parts; others may exist
+//            but are not encoded.
+//
+// See concept-model/TODO.hyperedge/00-design-overview.md for the design
+// rationale and the open/closed distinction.
+
+export const PARTITIVE_ENUMERATION = Object.freeze({
+  CLOSED: 'closed',
+  OPEN: 'open',
+});
+
+export const PARTITIVE_ENUMERATION_VALUES = Object.freeze([
+  PARTITIVE_ENUMERATION.CLOSED,
+  PARTITIVE_ENUMERATION.OPEN,
+]);
+
+export function isValidPartitiveEnumeration(value) {
+  return PARTITIVE_ENUMERATION_VALUES.includes(value);
+}

package/src/models/partitive-hyperedge.js

@@ -0,0 +1,175 @@
+// PartitiveHyperedge — a one-to-many partitive decomposition.
+//
+// One comprehensive concept (the whole) is related to one or more
+// parts as a SINGLE relationship. Captures invariants that binary
+// RelatedConcept edges cannot:
+//
+//   - which comprehensive owns which parts (set membership)
+//   - plurality markers from the source diagram (double / dashed)
+//   - enumeration completeness (closed: all parts listed; open:
+//     other parts may exist)
+//
+// See concept-model/TODO.hyperedge/00-design-overview.md for the
+// design rationale.
+//
+// Hyperedges coexist with binary `broader_partitive` /
+// `narrower_partitive` edges. Use a binary edge for pairwise
+// relationships without diagram metadata; use a hyperedge when the
+// relationship is one-to-many with enumeration/marker metadata.
+
+import { GlossaristModel } from './base.js';
+import { ConceptRef } from './concept-ref.js';
+import {
+  PARTITIVE_ENUMERATION,
+  PARTITIVE_ENUMERATION_VALUES,
+  isValidPartitiveEnumeration,
+} from './partitive-enumeration.js';
+import {
+  PLURALITY_MARKER_VALUES,
+  isValidPluralityMarker,
+} from './plurality-marker.js';
+
+const DEFAULT_ENUMERATION = PARTITIVE_ENUMERATION.CLOSED;
+
+export class PartitiveHyperedge extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.comprehensive = ensureConceptRef(data.comprehensive, 'comprehensive');
+    this.parts = ensureConceptRefArray(data.parts, 'parts');
+    this.enumeration = resolveEnumeration(data.enumeration);
+    this.markers = validateMarkers(data.markers ?? []);
+    this.content = normalizeContent(data.content);
+
+    assertNonEmptyParts(this.parts);
+    assertNoSelfLoop(this.comprehensive, this.parts);
+  }
+
+  get isClosed() { return this.enumeration === PARTITIVE_ENUMERATION.CLOSED; }
+  get isOpen() { return this.enumeration === PARTITIVE_ENUMERATION.OPEN; }
+  get isMarked() { return this.markers.length > 0; }
+
+  hasMarker(value) {
+    return this.markers.includes(value);
+  }
+
+  hasEnumeration(value) {
+    return this.enumeration === value;
+  }
+
+  get contentString() {
+    if (!this.content) return null;
+    const values = Object.values(this.content);
+    return values.length > 0 ? values[0] : null;
+  }
+
+  toJSON() {
+    const obj = {
+      comprehensive: this.comprehensive.toJSON(),
+      parts: this.parts.map(p => p.toJSON()),
+      enumeration: this.enumeration,
+    };
+    if (this.markers.length > 0) obj.markers = [...this.markers];
+    if (this.content != null) obj.content = this.content;
+    return obj;
+  }
+
+  static identityOf(value) {
+    const v = value ?? {};
+    const c = v.comprehensive ?? {};
+    const parts = Array.isArray(v.parts) ? v.parts : [];
+    const partsStr = parts
+      .map(p => `${p?.source ?? ''}:${p?.id ?? ''}`)
+      .sort();
+    return `${c.source ?? ''}:${c.id ?? ''}|${partsStr.join('|')}`;
+  }
+
+  identity() {
+    return PartitiveHyperedge.identityOf(this);
+  }
+
+  static fromJSON(data) {
+    return new PartitiveHyperedge(data);
+  }
+}
+
+function resolveEnumeration(value) {
+  if (value == null) return DEFAULT_ENUMERATION;
+  if (!isValidPartitiveEnumeration(value)) {
+    throw new Error(
+      `invalid enumeration ${JSON.stringify(value)}; ` +
+      `must be one of ${PARTITIVE_ENUMERATION_VALUES.join(', ')}`,
+    );
+  }
+  return value;
+}
+
+function validateMarkers(values) {
+  const arr = Array.isArray(values) ? values : [values];
+  const seen = new Set();
+  for (const m of arr) {
+    if (!isValidPluralityMarker(m)) {
+      throw new Error(
+        `invalid plurality marker ${JSON.stringify(m)}; ` +
+        `must be one of ${PLURALITY_MARKER_VALUES.join(', ')}`,
+      );
+    }
+    if (seen.has(m)) {
+      throw new Error(
+        `duplicate plurality marker ${JSON.stringify(m)} in partitive_hyperedge`,
+      );
+    }
+    seen.add(m);
+  }
+  return arr;
+}
+
+function ensureConceptRef(value, fieldName) {
+  const ref = value instanceof ConceptRef ? value : new ConceptRef(value ?? {});
+  if (!ref.source && !ref.id) {
+    throw new Error(
+      `PartitiveHyperedge#${fieldName} must be a non-empty ConceptRef ` +
+      `(source or id required)`,
+    );
+  }
+  return ref;
+}
+
+function ensureConceptRefArray(values, fieldName) {
+  if (!Array.isArray(values)) values = values == null ? [] : [values];
+  return values.map((v, i) => ensureConceptRef(v, `${fieldName}[${i}]`));
+}
+
+function assertNonEmptyParts(parts) {
+  if (!parts || parts.length === 0) {
+    throw new Error('PartitiveHyperedge requires at least one part');
+  }
+}
+
+function assertNoSelfLoop(comprehensive, parts) {
+  const cKey = `${comprehensive.source ?? ''}:${comprehensive.id ?? ''}`;
+  for (const p of parts) {
+    const pKey = `${p.source ?? ''}:${p.id ?? ''}`;
+    if (pKey === cKey) {
+      throw new Error('PartitiveHyperedge#parts cannot include the comprehensive');
+    }
+  }
+}
+
+// Content is a localized string (language -> text). Plain strings on
+// input are normalized to `{ default: '...' }` so callers always see
+// the same shape. `null` is preserved.
+//
+// Cross-repo symmetry: glossarist-ruby's `PartitiveHyperedge#content=`
+// (lib/glossarist/v3/partitive_hyperedge.rb) applies the same
+// normalization since commit c917846 (was previously a plain string;
+// aligned with invariant I7 in TODO.hyperedges round 1, item 29).
+// Datasets now round-trip identically across repos.
+function normalizeContent(value) {
+  if (value == null) return null;
+  if (typeof value === 'string') return { default: value };
+  if (typeof value === 'object') {
+    const entries = Object.entries(value).filter(([, v]) => typeof v === 'string');
+    return entries.length > 0 ? Object.fromEntries(entries) : null;
+  }
+  return null;
+}

package/src/models/partitive-member.js

@@ -0,0 +1,96 @@
+// PartitiveMember — one member of a PartitiveRelation.
+//
+// Carries a ConceptRef (the subordinate concept partitive) plus
+// ISO 704:2022 multiplicity and delimiting metadata.
+//
+// ISO 704:2022 partitive member notation:
+//
+//   multiplicity (diagram line notation):
+//     compulsory          — 1 solid line (must exist in every instance)
+//     optional            — 1 dashed line (exists in some instances only)
+//     compulsory_multiple — 2 solid lines (multiple must exist)
+//     optional_multiple   — 2 dashed lines (multiple may exist)
+//     at_least_one        — 1 solid + 1 dashed line (≥1 must exist)
+//
+//   is_delimiting (orthogonal, bold 3x-width line in diagram):
+//     A delimiting part behaves like a delimiting characteristic:
+//     it distinguishes the comprehensive from coordinate concepts.
+
+import { GlossaristModel } from './base.js';
+import { ConceptRef } from './concept-ref.js';
+import {
+  MULTIPLICITY,
+  DEFAULT_MULTIPLICITY,
+  MULTIPLICITY_VALUES,
+  isValidMultiplicity,
+} from './multiplicity.js';
+
+export class PartitiveMember extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.ref = data.ref instanceof ConceptRef
+      ? data.ref
+      : new ConceptRef(data.ref ?? {});
+    this.multiplicity = _resolveMultiplicity(data.multiplicity);
+    this.is_delimiting = data.is_delimiting === true;
+
+    _assertNonEmptyRef(this.ref);
+  }
+
+  get isCompulsory() {
+    return this.multiplicity === MULTIPLICITY.COMPULSORY;
+  }
+
+  get isOptional() {
+    return this.multiplicity === MULTIPLICITY.OPTIONAL;
+  }
+
+  get isDelimiting() {
+    return this.is_delimiting === true;
+  }
+
+  identity() {
+    return PartitiveMember.identityOf(this);
+  }
+
+  toJSON() {
+    const obj = { ref: this.ref.toJSON() };
+    if (this.multiplicity !== DEFAULT_MULTIPLICITY) {
+      obj.multiplicity = this.multiplicity;
+    }
+    if (this.is_delimiting === true) {
+      obj.is_delimiting = true;
+    }
+    return obj;
+  }
+
+  static identityOf(value) {
+    const v = value ?? {};
+    const ref = v.ref ?? {};
+    return `${ref.source ?? ''}:${ref.id ?? ''}`;
+  }
+
+  static fromJSON(data) {
+    return new PartitiveMember(data);
+  }
+}
+
+function _resolveMultiplicity(value) {
+  if (value == null) return DEFAULT_MULTIPLICITY;
+  if (!isValidMultiplicity(value)) {
+    throw new Error(
+      `invalid multiplicity ${JSON.stringify(value)}; ` +
+      `must be one of ${MULTIPLICITY_VALUES.join(', ')}`,
+    );
+  }
+  return value;
+}
+
+function _assertNonEmptyRef(ref) {
+  if (!ref.source && !ref.id && !ref.text) {
+    throw new Error(
+      'PartitiveMember#ref must be a non-empty ConceptRef ' +
+      '(source, id, or text required)',
+    );
+  }
+}

package/src/models/partitive-relation.js

@@ -0,0 +1,149 @@
+// PartitiveRelation — an ISO 704 / ISO 1087-1 / ISO 12620
+// partitive relation connecting a comprehensive concept
+// (superordinate concept partitive) to two or more partitive
+// concepts (subordinate concepts partitive) which fitted together
+// constitute the comprehensive.
+//
+// Field renames (v1 → v2):
+//   parts [1..*]              → partitives [2..*]  (as PartitiveMember)
+//   enumeration: closed|open  → completeness: complete|partial
+//   content: LocalizedString  → (dropped — structural edges carry no prose)
+//
+// Per-member metadata (ISO 704:2022):
+//   multiplicity (5 values) + is_delimiting (boolean)
+//
+// New field:
+//   criterion: LocalizedString [0..1]  (ISO 12620 coordinate-concept coherence)
+//
+// Distinguished from binary `has_part` / `is_part_of` edges, which
+// express pairwise part-of assertions without completeness,
+// multiplicity, or criterion claims. A single partitive should be
+// expressed as a binary edge, not a PartitiveRelation (ISO requires
+// "two or more").
+
+import { GlossaristModel } from './base.js';
+import { ConceptRef } from './concept-ref.js';
+import { PartitiveMember } from './partitive-member.js';
+import {
+  COMPLETENESS,
+  COMPLETENESS_VALUES,
+  DEFAULT_COMPLETENESS,
+  isValidCompleteness,
+} from './completeness.js';
+
+export class PartitiveRelation extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.comprehensive = _ensureComprehensive(data.comprehensive);
+    this.partitives = _ensurePartitives(data.partitives);
+    this.completeness = _resolveCompleteness(data.completeness);
+    this.criterion = _normalizeCriterion(data.criterion);
+
+    _assertNoSelfLoop(this.comprehensive, this.partitives);
+  }
+
+  get isComplete() { return this.completeness === COMPLETENESS.COMPLETE; }
+  get isPartial() { return this.completeness === COMPLETENESS.PARTIAL; }
+
+  // ISO 12620 coordinate-concept predicate: a relation is "coordinate"
+  // when it has ≥2 partitives (all partitives within one relation are
+  // coordinate concepts by definition).
+  get isCoordinate() { return this.partitives.length >= 2; }
+
+  hasCriterion() { return this.criterion != null; }
+
+  identity() {
+    return PartitiveRelation.identityOf(this);
+  }
+
+  toJSON() {
+    const obj = {
+      comprehensive: this.comprehensive.toJSON(),
+      partitives: this.partitives.map(p => p.toJSON()),
+      completeness: this.completeness,
+    };
+    if (this.criterion != null) obj.criterion = { ...this.criterion };
+    return obj;
+  }
+
+  // Stable identity for diffing: same comprehensive + same partitive
+  // set (by ref identity) = same relation. Changes to completeness,
+  // multiplicity, is_delimiting, or criterion produce "changed"
+  // entries rather than add+remove.
+  static identityOf(value) {
+    const v = value ?? {};
+    const c = v.comprehensive ?? {};
+    const partitiveKeys = Array.isArray(v.partitives)
+      ? v.partitives.map(p => {
+          const r = p?.ref ?? p ?? {};
+          return `${r.source ?? ''}:${r.id ?? ''}`;
+        }).sort()
+      : [];
+    return `${c.source ?? ''}:${c.id ?? ''}|${partitiveKeys.join('|')}`;
+  }
+
+  static fromJSON(data) {
+    return new PartitiveRelation(data);
+  }
+}
+
+function _ensureComprehensive(value) {
+  const ref = value instanceof ConceptRef ? value : new ConceptRef(value ?? {});
+  if (!ref.source && !ref.id && !ref.text) {
+    throw new Error(
+      'PartitiveRelation.comprehensive must be a non-empty ConceptReference ' +
+      '(source, id, or text required)',
+    );
+  }
+  return ref;
+}
+
+function _ensurePartitives(values) {
+  if (!Array.isArray(values)) {
+    throw new Error(
+      `PartitiveRelation.partitives must be an array (got ${typeof values})`,
+    );
+  }
+  if (values.length < 2) {
+    throw new Error(
+      `PartitiveRelation requires ≥2 partitives (ISO 704); got ${values.length}`,
+    );
+  }
+  return values.map(v => v instanceof PartitiveMember ? v : new PartitiveMember(v));
+}
+
+function _resolveCompleteness(value) {
+  const c = value ?? DEFAULT_COMPLETENESS;
+  if (!isValidCompleteness(c)) {
+    throw new Error(
+      `PartitiveRelation.completeness has invalid value ${JSON.stringify(value)}; ` +
+      `must be one of: ${COMPLETENESS_VALUES.join(', ')}`,
+    );
+  }
+  return c;
+}
+
+function _normalizeCriterion(value) {
+  if (value == null) return null;
+  if (typeof value === 'string') {
+    return value.length > 0 ? { default: value } : null;
+  }
+  if (typeof value === 'object') {
+    const entries = Object.entries(value).filter(([, v]) => typeof v === 'string');
+    return entries.length > 0 ? Object.fromEntries(entries) : null;
+  }
+  return null;
+}
+
+function _assertNoSelfLoop(comprehensive, partitives) {
+  const cKey = `${comprehensive.source ?? ''}:${comprehensive.id ?? ''}`;
+  for (const p of partitives) {
+    const ref = p.ref;
+    const pKey = `${ref.source ?? ''}:${ref.id ?? ''}`;
+    if (pKey === cKey && (ref.source || ref.id)) {
+      throw new Error(
+        'PartitiveRelation.partitives cannot include the comprehensive (no self-loops)',
+      );
+    }
+  }
+}

package/src/models/plurality-marker.js

@@ -0,0 +1,24 @@
+// PluralityMarker — diagram notation flags from VIM concept-relationship
+// diagrams. Travels with a PartitiveHyperedge so the rendering layer
+// can reproduce the source diagram's notation.
+//
+//   double — close-set double line at the receiver end. Several
+//            partitive concepts of the same type are involved.
+//   dashed — broken/dashed line. Plurality is uncertain.
+//
+// Orthogonal to PartitiveEnumeration — both may be set on the same
+// hyperedge.
+
+export const PLURALITY_MARKER = Object.freeze({
+  DOUBLE: 'double',
+  DASHED: 'dashed',
+});
+
+export const PLURALITY_MARKER_VALUES = Object.freeze([
+  PLURALITY_MARKER.DOUBLE,
+  PLURALITY_MARKER.DASHED,
+]);
+
+export function isValidPluralityMarker(value) {
+  return PLURALITY_MARKER_VALUES.includes(value);
+}

package/src/models/related-concept.js

@@ -25,6 +25,11 @@ export const RELATIONSHIP_TYPES = Object.freeze([
   // Associative (ISO 10241-1 / ISO 25964)
   'see', 'related_concept', 'related_concept_broader', 'related_concept_narrower',
   'references',
+  // ExternalConcept resolution (Glossarist extension — v2 partitive-relation)
+  // Direction: real concept `provides` substance for an external concept;
+  // external concept `provided_by` real concept. Stored on the
+  // ExternalConcept. See TODO.partitive-relation-v2 item 07.
+  'provides', 'provided_by',
   // Comparative (ISO 10241-1)
   'compare', 'contrast',
   // Spatiotemporal (ISO 25964 / TBX)

package/src/models/relation-categories.js

@@ -96,6 +96,11 @@ export const RELATION_CATEGORIES = Object.freeze({
   // (a version IS a definitional variant of the same concept identity).
   // Renaming aligns glossarist-js with the canonical taxonomy at
   // concept-browser:src/data/taxonomies.json.
+  //
+  // `provides` / `provided_by` (Glossarist v2 extension) live here too:
+  // they record ExternalConcept resolution — a definitional linkage
+  // between a placeholder and the concept that fills its substance.
+  // See TODO.partitive-relation-v2 item 07.
   definitional: Object.freeze({
     label: 'Definitional',
     description: 'ISO 19135 concept-to-concept relations: definition, part, instance, inheritance, versioning.',
@@ -107,6 +112,7 @@ export const RELATION_CATEGORIES = Object.freeze({
       'inherits', 'inherited_by',
       'has_version', 'version_of',
       'current_version', 'current_version_of',
+      'provides', 'provided_by',
     ]),
   }),
 });