glossarist 2.12.0 → 2.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4895d3a9f92f0c592e14932542e717c86d6c3b4559eec4ae133f056b99aeaae5
-  data.tar.gz: 0aeac1eb4550d81deba20330d9744b73144fbfb50f28e01aec1f55af9410ee9a
+  metadata.gz: 85ff1a35136e9b7ff920830b2bf9a2e4b477bffed405c2386e33739ed6560a45
+  data.tar.gz: f7ef8fb96a58eb21a71534fcc8afc1cf7f26053379cfb00e5ec98098620ca6a6
 SHA512:
-  metadata.gz: edd2a440b12a2423a5725036568b85734017e400727db62f166097d71cffaef29abe588ceef136f5b25b06f9904fabafd4500fe6cf461416736b3d02e2ca1b06
-  data.tar.gz: ef423629a5f612d5fe6d3d84323d2acc5ae0a5a0aff9903578ac72f3dae01e997a60104d8b8f5e5bb55e7c2c667c3f9753274d804fff9913cb0fd7deed694da0
+  metadata.gz: beeecf5f816d5ec10741375d357a1b3602e7d415ebedfc71eff52d414f1d623ed119c7995355231c147020f54b814dc8306d37acdc6eecacdf8ca72ec6ddd65f
+  data.tar.gz: 0a7de5bd20f0f7c58c1c08066983b5c490999570249b686f84f60bd87df9b5e436913db66e43b5d1003805bfa33a6613d67bbd8c49373d21a03815dde83a8e42

data/CLAUDE.md

@@ -35,6 +35,48 @@ All model classes use `Lutaml::Model::Serializable` for serialization.
 - **`ConceptReference`** (`concept_reference.rb`) — a typed reference to another concept. Local refs use `concept_id` alone; external refs use `source` (URN prefix) + `concept_id` or a direct `urn` field. Has `local?`/`external?` predicates. No `to_gcr_hash` or `from_urn` — model-driven architecture uses lutaml-model for serialization; URN construction/parsing belongs in `UrnResolver`.
 - **`RelatedConcept`** (`related_concept.rb`) — a concept with a typed relationship. Relationship types cover ISO 10241-1 (deprecates/supersedes/superseded_by/compare/contrast/see), ISO 25964/SKOS (broader/narrower/broader_generic/narrower_generic/broader_partitive/narrower_partitive/broader_instantial/narrower_instantial/equivalent/close_match/broad_match/narrow_match/related_match), ISO 12620/TBX (homograph/false_friend/related_concept/related_concept_broader/related_concept_narrower/sequentially_related_concept/spatially_related_concept/temporally_related_concept), and designation-level (abbreviated_form_for/short_form_for). Types are defined in `config.yml` under `related_concept.type`.
 
+#### V3 `related` placement (MECE)
+
+In V3, `related` lives **only** on `V3::ManagedConcept#related`.
+`V3::ManagedConceptData` does NOT declare or serialize `related`.
+V2 placed `related` inside data; the `SchemaMigration::V2ToV3#step_v2_to_v3`
+migration moves any data-level entries up to the concept level. The
+V3 output never carries `related` at the data level.
+
+This consolidation closes the legacy trap where writing to
+`data.related` bypassed `ManagedConcept.detect_schema_version` (which
+keys off `concept.related`).
+
+### PartitiveRelation (V3 only)
+
+`PartitiveRelation` (`v3/partitive_relation.rb`) — an ISO 704 / ISO 1087-1 / ISO 12620 partitive relation. One comprehensive concept (superordinate concept partitive) is connected to two or more partitive concepts (subordinate concepts partitive) which fitted together constitute the comprehensive.
+
+Each PartitiveRelation carries:
+
+- `comprehensive` — ConceptRef to the superordinate concept partitive (the whole)
+- `partitives` — `PartitiveMember [2..*]` (ISO 704 "two or more"); each member wraps a ConceptRef plus optional `MemberCertainty` (`confirmed` default, `possible`)
+- `completeness` — `complete` (default; the encoded partitives constitute the whole) or `partial` (others exist beyond those encoded). ISO 704 rake backline notation.
+- `plurality` — optional `TypeSharedPlurality` block (ISO 704 close-set double line promoted to data: `is_shared`, `is_uncertain`, `shared_type`). Replaces the prior opaque `markers` field.
+- `criterion` — optional localized string hash (`{ "eng" => "physical structure" }`). ISO 12620 coordinate-concept coherence: partitives within one relation share the comprehensive AND the criterion.
+
+Wired into `V3::ManagedConcept#partitive_relations`. NOT on `ManagedConceptData` (relationships live at the concept level for MECE consistency with `related`).
+
+Enum values are SSOT-loaded from `config.yml` via `GlossaryDefinition::COMPLETENESS_VALUES` and `MEMBER_CERTAINTY_VALUES`. The `values:` option on each attribute documents the enum; the model's `validate!` method enforces structural invariants after construction (empty comprehensive, <2 partitives, self-loops, incoherent plurality, invalid enum values).
+
+Semantic checks (≥2 partitives cardinality, duplicate comprehensive+criterion detection, criterion-absent warning, ExternalConcept shape) live in `Validation::Rules::PartitiveRelationRule` (auto-registered by `Validation::Rules`, code GLS-221).
+
+RDF emission: `Rdf::GlossPartitiveRelation` view class with companion `GlossPartitiveMember` and `GlossTypeSharedPlurality`. Wired into `Transforms::ConceptToGlossTransform` and emitted as `gloss:hasPartitiveRelation` link from `GlossConcept`.
+
+Binary `broader_partitive`/`narrower_partitive`/`has_part`/`is_part_of` `RelatedConcept` edges and `PartitiveRelation` coexist — no automatic consolidation. Use a binary edge for pairwise relationships; use a PartitiveRelation when membership is jointly significant (≥2 partitives + completeness/plurality/criterion metadata).
+
+#### ExternalConcept
+
+`status: external` is a value of `ConceptStatus` (not a separate class). A concept with `status: external` is referenced from this dataset but defined elsewhere — ISO 704 "parenthetic term" semantic role. Required fields (definition, sources) are relaxed; at least one designation is still required. Resolves to another dataset's concept via `provided_by` when a defining dataset is loaded.
+
+#### Relationship type extensions
+
+Two new values in `RelatedConceptType`: `provides` (real concept → external concept) and `provided_by` (external concept → real concept). Inverse pair, established at the collection level.
+
 ### Reference Resolution
 
 - **`ReferenceExtractor`** (`reference_extractor.rb`) — extracts `ConceptReference` and `AssetReference` objects from `{{...}}` mentions and `image::...[]` references in concept text fields.

data/config.yml

@@ -101,6 +101,12 @@ related_concept:
     - version_of
     - current_version
     - current_version_of
+    # ExternalConcept resolution (Glossarist extension)
+    # Real concept `provides` substance for an external concept;
+    # external concept `provided_by` real concept. Inverse pair.
+    # Established at the collection level when both datasets are loaded.
+    - provides
+    - provided_by
 
 iso12620:
   term_type:
@@ -178,6 +184,10 @@ concept:
     - valid
     - superseded
     - retired
+    # Glossarist extension: concept referenced from this dataset but
+    # defined elsewhere. Resolves via `provided_by` when a defining
+    # dataset is loaded. ISO 704 "parenthetic term" semantic role.
+    - external
 
 concept_date:
   type:
@@ -186,3 +196,24 @@ concept_date:
     - retired
     - review
     - review_decision
+
+# PartitiveRelation redesign (TODO.partitive-relation-v2)
+# Replaces partitive_enumeration + plurality_marker.
+
+completeness:
+  # Whether the encoded partitives fitted together constitute the
+  # whole comprehensive concept (complete) or only some of it
+  # (partial — other partitives exist but are not encoded).
+  # ISO 704: rake backline ending with a tooth = complete;
+  # backline continuing without a tooth = partial.
+  # Default: complete.
+  value:
+    - complete
+    - partial
+
+member_certainty:
+  # Per-partitive certainty. Glossarist extension beyond ISO 704
+  # notation. Defaults to confirmed when omitted.
+  value:
+    - confirmed
+    - possible

data/lib/glossarist/designation/designation_relationship.rb

@@ -3,7 +3,7 @@
 module Glossarist
   module Designation
     class DesignationRelationship < Lutaml::Model::Serializable
-      attribute :content, :string
+      attribute :content, :hash
       attribute :type, :string,
                 values: Glossarist::GlossaryDefinition::DESIGNATION_RELATIONSHIP_TYPES
       attribute :target, :string

data/lib/glossarist/glossary_definition.rb

@@ -33,5 +33,11 @@ module Glossarist
                                                 "relationship_type")&.freeze
 
     ISO12620_TERM_TYPES = config.dig("iso12620", "term_type").freeze
+
+    # PartitiveRelation redesign (TODO.partitive-relation-v2).
+    # Replaces PARTITIVE_ENUMERATION_VALUES + PLURALITY_MARKER_VALUES.
+    COMPLETENESS_VALUES = config.dig("completeness", "value").freeze
+
+    MEMBER_CERTAINTY_VALUES = config.dig("member_certainty", "value").freeze
   end
 end

data/lib/glossarist/managed_concept.rb

@@ -174,6 +174,8 @@ module Glossarist
       return "3" if concept.related&.any?
       return "3" if concept.sources&.any?
       return "3" if concept.data&.domains&.any?
+      return "3" if concept.is_a?(V3::ManagedConcept) &&
+                     concept.partitive_relations&.any?
       return "3" if localization_has_references?(concept)
 
       "2"

data/lib/glossarist/rdf/gloss_concept.rb

@@ -11,6 +11,7 @@ module Glossarist
       attribute :sources, GlossConceptSource, collection: true
       attribute :domains, GlossConceptReference, collection: true
       attribute :dates, GlossConceptDate, collection: true
+      attribute :partitive_relations, GlossPartitiveRelation, collection: true
 
       RelationshipPredicates::CONCEPT_REL_PREDICATES.each_key do |type|
         attribute :"#{type}_targets", :string, collection: true
@@ -41,6 +42,8 @@ module Glossarist
                 link: "gloss:hasDomain"
         members :dates,
                 link: "gloss:hasDate"
+        members :partitive_relations,
+                link: "gloss:hasPartitiveRelation"
 
         RelationshipPredicates::CONCEPT_REL_PREDICATES.each do |type, (ns, name)|
           predicate name, namespace: ns, to: :"#{type}_targets",

data/lib/glossarist/rdf/gloss_partitive_member.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    # RDF view for V3::PartitiveMember. Emits a
+    # gloss:PartitiveMember subject with ref + certainty properties.
+    class GlossPartitiveMember < Lutaml::Model::Serializable
+      attribute :ref_id, :string
+      attribute :ref_source, :string
+      attribute :ref_text, :string
+      attribute :certainty, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |m| "partitiveMember/#{m.ref_source}:#{m.ref_id}" }
+
+        types "gloss:PartitiveMember"
+
+        predicate :refSource, namespace: Namespaces::GlossaristNamespace,
+                              to: :ref_source
+        predicate :refId, namespace: Namespaces::GlossaristNamespace,
+                          to: :ref_id
+        predicate :refText, namespace: Namespaces::GlossaristNamespace,
+                            to: :ref_text
+        predicate :certainty, namespace: Namespaces::GlossaristNamespace,
+                              to: :certainty
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_partitive_relation.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    # RDF view for V3::PartitiveRelation. Emits a
+    # gloss:PartitiveRelation subject with comprehensive, hasPartitive,
+    # completeness, hasPlurality, criterion properties.
+    class GlossPartitiveRelation < Lutaml::Model::Serializable
+      attribute :identifier, :string
+      attribute :comprehensive_uri, :string
+      attribute :partitive_member_ids, :string, collection: true
+      attribute :completeness, :string
+      attribute :has_plurality, GlossTypeSharedPlurality
+      attribute :criterion, :hash
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |r| "partitiveRelation/#{r.identifier}/#{r.object_id}" }
+
+        types "gloss:PartitiveRelation"
+
+        predicate :comprehensive, namespace: Namespaces::GlossaristNamespace,
+                                  to: :comprehensive_uri, uri_reference: true
+        predicate :hasPartitive, namespace: Namespaces::GlossaristNamespace,
+                                 to: :partitive_member_ids, uri_reference: true
+        predicate :completeness, namespace: Namespaces::GlossaristNamespace,
+                                 to: :completeness, uri_reference: true
+        members :has_plurality,
+                link: "gloss:hasPlurality"
+        predicate :criterion, namespace: Namespaces::GlossaristNamespace,
+                              to: :criterion
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_type_shared_plurality.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    # RDF view for V3::TypeSharedPlurality. Emits a
+    # gloss:TypeSharedPlurality subject with is_shared, is_uncertain,
+    # shared_type properties.
+    class GlossTypeSharedPlurality < Lutaml::Model::Serializable
+      attribute :is_shared, :boolean
+      attribute :is_uncertain, :boolean
+      attribute :shared_type_uri, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |p| "plurality/#{p.object_id}" }
+
+        types "gloss:TypeSharedPlurality"
+
+        predicate :isShared, namespace: Namespaces::GlossaristNamespace,
+                             to: :is_shared
+        predicate :isUncertain, namespace: Namespaces::GlossaristNamespace,
+                                to: :is_uncertain
+        predicate :sharedType, namespace: Namespaces::GlossaristNamespace,
+                               to: :shared_type_uri, uri_reference: true
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/v3.rb

@@ -29,6 +29,9 @@ module Glossarist
         GlossFigureImage
         GlossTable
         GlossFormula
+        GlossPartitiveRelation
+        GlossPartitiveMember
+        GlossTypeSharedPlurality
       ].freeze
 
       VIEW_CLASS_NAMES.each do |name|

data/lib/glossarist/rdf.rb

@@ -42,6 +42,10 @@ module Glossarist
     autoload :GlossFigureImage,       "#{__dir__}/rdf/gloss_figure_image"
     autoload :GlossTable,             "#{__dir__}/rdf/gloss_table"
     autoload :GlossFormula,           "#{__dir__}/rdf/gloss_formula"
+    autoload :GlossPartitiveRelation, "#{__dir__}/rdf/gloss_partitive_relation"
+    autoload :GlossPartitiveMember,   "#{__dir__}/rdf/gloss_partitive_member"
+    autoload :GlossTypeSharedPlurality,
+             "#{__dir__}/rdf/gloss_type_shared_plurality"
     autoload :V3,                     "#{__dir__}/rdf/v3"
   end
 end

data/lib/glossarist/related_concept.rb

@@ -2,7 +2,7 @@
 
 module Glossarist
   class RelatedConcept < Lutaml::Model::Serializable
-    attribute :content, :string
+    attribute :content, :hash
     attribute :type, :string,
               values: Glossarist::GlossaryDefinition::RELATED_CONCEPT_TYPES
     attribute :ref, ConceptRef

data/lib/glossarist/schema_migration/v2_to_v3.rb

@@ -38,11 +38,25 @@ module Glossarist
       end
 
       def self.step_v2_to_v3(concept)
-        if concept.data&.related&.any?
-          concept.related ||= []
-          concept.related = (concept.related + concept.data.related).uniq
-          concept.data.related = []
-        end
+        # V2 placed `related` inside ManagedConceptData; V3 places it
+        # on ManagedConcept itself. Move any data-level related entries
+        # up to the concept level. V3::ManagedConceptData no longer
+        # serializes `related`, so we don't need to clear the moved-from
+        # slot — the V3 output naturally omits it.
+        data_related = concept.data&.related
+        return step_v2_to_v3_hyperedge_note if data_related.nil? || data_related.empty?
+
+        concept.related ||= []
+        concept.related = (concept.related + data_related).uniq
+        "3"
+      end
+
+      # Hyperedges: V2 has no hyperedge concept. V2's binary
+      # `broader_partitive` / `narrower_partitive` edges migrate as
+      # `related` entries (see step_v2_to_v3). Hyperedges are a V3-only
+      # construct and require no migration logic — concepts upgraded
+      # from V2 to V3 simply have no hyperedges.
+      def self.step_v2_to_v3_hyperedge_note
         "3"
       end
     end

data/lib/glossarist/transforms/concept_to_gloss_transform.rb

@@ -130,10 +130,66 @@ module Glossarist
           domains: build_gloss_domains(managed_concept.data&.domains,
                                        identifier),
           dates: build_gloss_dates(managed_concept.dates, identifier),
+          partitive_relations: build_gloss_partitive_relations(
+            v3_partitive_relations(managed_concept), identifier,
+          ),
           **rel_targets,
         )
       end
 
+      # PartitiveRelations are a V3-only attribute. The transform
+      # accepts both V1/V2 and V3 concepts; for V1/V2 concepts the
+      # relation list is always empty.
+      def v3_partitive_relations(managed_concept)
+        return [] unless managed_concept.is_a?(V3::ManagedConcept)
+
+        managed_concept.partitive_relations
+      end
+
+      def build_gloss_partitive_relations(relations, identifier)
+        return [] unless relations
+
+        Array(relations).map do |rel|
+          Rdf::GlossPartitiveRelation.new(
+            identifier: identifier.to_s,
+            comprehensive_uri: partitive_concept_uri(rel.comprehensive),
+            partitive_member_ids: Array(rel.partitives).map do |m|
+              partitive_member_uri(m)
+            end,
+            completeness: rel.completeness,
+            has_plurality: build_gloss_plurality(rel.plurality),
+            criterion: rel.criterion,
+          )
+        end
+      end
+
+      def build_gloss_plurality(plurality)
+        return nil unless plurality
+
+        Rdf::GlossTypeSharedPlurality.new(
+          is_shared: plurality.is_shared,
+          is_uncertain: plurality.is_uncertain,
+          shared_type_uri: partitive_concept_uri(plurality.shared_type),
+        )
+      end
+
+      def partitive_concept_uri(ref)
+        return nil unless ref.is_a?(Glossarist::ConceptRef)
+
+        Glossarist::Rdf::Namespaces::GlossaristNamespace.uri +
+          "concept/#{ref.id || ref.text}"
+      end
+
+      def partitive_member_uri(member)
+        return nil unless member.is_a?(V3::PartitiveMember)
+
+        ref = member.ref
+        return nil unless ref.is_a?(Glossarist::ConceptRef)
+
+        Glossarist::Rdf::Namespaces::GlossaristNamespace.uri +
+          "concept/#{ref.id || ref.text}"
+      end
+
       def build_gloss_localized_concept(l10n, concept_id)
         lang = l10n.language_code
         data = l10n.data

data/lib/glossarist/v3/managed_concept.rb

@@ -5,6 +5,7 @@ module Glossarist
     class ManagedConcept < Glossarist::ManagedConcept
       attribute :data, V3::ManagedConceptData, default: -> { V3::ManagedConceptData.new }
       attribute :related, V3::RelatedConcept, collection: true
+      attribute :partitive_relations, V3::PartitiveRelation, collection: true
       attribute :dates, V3::ConceptDate, collection: true
       attribute :date_accepted, V3::ConceptDate
       attribute :sources, V3::ConceptSource, collection: true
@@ -12,6 +13,7 @@ module Glossarist
       key_value do
         map :data, to: :data
         map :related, to: :related
+        map :partitive_relations, to: :partitive_relations
         map :dates, to: :dates
         map %i[date_accepted dateAccepted],
             with: { from: :date_accepted_from_yaml, to: :date_accepted_to_yaml }

data/lib/glossarist/v3/managed_concept_data.rb

@@ -2,6 +2,20 @@
 
 module Glossarist
   module V3
+    # V3 ManagedConceptData — the data payload inside a V3::ManagedConcept.
+    #
+    # V3 placement rule (MECE): `related` lives ONLY on V3::ManagedConcept,
+    # not on its data payload. V2 placed `related` inside data; the
+    # V2→V3 migration (SchemaMigration::V2ToV3) moves it to the concept
+    # level. Keeping `related` writable on V3 data would re-open the
+    # trap where writing to `data.related` bypasses
+    # `ManagedConcept.detect_schema_version` (which keys off
+    # `concept.related`).
+    #
+    # The base class Glossarist::ManagedConceptData still declares
+    # `related` for V1/V2 compatibility; V3 overrides that with an
+    # empty attribute via `attribute :related, nil` so the slot is
+    # inert and serializes nothing.
     class ManagedConceptData < Glossarist::ManagedConceptData
       attribute :sources, V3::ConceptSource, collection: true
       attribute :localizations, V3::LocalizedConcept,
@@ -17,7 +31,6 @@ module Glossarist
                                 with: { from: :domains_from_yaml, to: :domains_to_yaml }
         map :tags, to: :tags
         map :sources, to: :sources
-        map :related, to: :related
         map :localizations, to: :localizations,
                             with: { from: :localizations_from_yaml, to: :localizations_to_yaml }
       end
@@ -34,3 +47,4 @@ module Glossarist
     end
   end
 end
+

data/lib/glossarist/v3/partitive_member.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    # PartitiveMember — one member of a PartitiveRelation, carrying
+    # a ConceptRef to the partitive concept plus optional certainty
+    # metadata (Glossarist extension beyond ISO 704 notation).
+    #
+    # A PartitiveMember with no certainty field is implicitly
+    # confirmed.
+    class PartitiveMember < Lutaml::Model::Serializable
+      DEFAULT_CERTAINTY = "confirmed"
+
+      attribute :ref, ConceptRef
+      attribute :certainty, :string,
+                values: Glossarist::GlossaryDefinition::MEMBER_CERTAINTY_VALUES,
+                default: -> { DEFAULT_CERTAINTY }
+
+      key_value do
+        map :ref, to: :ref
+        map :certainty, to: :certainty
+      end
+
+      def validate!
+        validate_ref!
+        validate_certainty!
+        self
+      end
+
+      def confirmed?
+        certainty == DEFAULT_CERTAINTY
+      end
+
+      def possible?
+        certainty == "possible"
+      end
+
+      private
+
+      def validate_ref!
+        return if ref.is_a?(ConceptRef) && (ref.source || ref.id || ref.text)
+
+        raise ArgumentError,
+              "PartitiveMember#ref must be a non-empty ConceptRef " \
+              "(source, id, or text required)"
+      end
+
+      def validate_certainty!
+        return if certainty.nil?
+
+        unless Glossarist::GlossaryDefinition::MEMBER_CERTAINTY_VALUES
+                 .include?(certainty)
+          raise ArgumentError,
+                "PartitiveMember#certainty has invalid value " \
+                "#{certainty.inspect}; must be one of " \
+                "#{GlossaryDefinition::MEMBER_CERTAINTY_VALUES.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/v3/partitive_relation.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    # 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.
+    #
+    # Shown as a rake or bracket in source diagrams. All partitives
+    # within one relation are coordinate concepts: they share the
+    # comprehensive AND share the criterion of subdivision.
+    #
+    # Glossarist extensions beyond ISO notation:
+    #   - Per-partitive certainty (MemberCertainty)
+    #   - plurality.shared_type (the type the partitives share)
+    #   - criterion as a structured field (not just diagrammatic)
+    #
+    # Replaces the prior PartitiveHyperedge class. The "hyperedge"
+    # framing was graph-theoretic; ISO calls this a *relation*.
+    class PartitiveRelation < Lutaml::Model::Serializable
+      DEFAULT_COMPLETENESS = "complete"
+
+      attribute :comprehensive, ConceptRef
+      attribute :partitives, PartitiveMember, collection: true
+      attribute :completeness, :string,
+                values: Glossarist::GlossaryDefinition::COMPLETENESS_VALUES,
+                default: -> { DEFAULT_COMPLETENESS }
+      attribute :plurality, TypeSharedPlurality
+      attribute :criterion, :hash
+
+      key_value do
+        map :comprehensive, to: :comprehensive
+        map :partitives, to: :partitives
+        map :completeness, to: :completeness
+        map :plurality, to: :plurality
+        map :criterion, to: :criterion
+      end
+
+      def validate!
+        validate_comprehensive!
+        validate_partitives!
+        validate_self_loop!
+        validate_completeness!
+        validate_plurality!
+        self
+      end
+
+      def complete?
+        completeness == "complete"
+      end
+
+      def partial?
+        completeness == "partial"
+      end
+
+      # ISO 704: a partitive relation connects to two or more
+      # partitives. A single binary has_part edge is not a
+      # PartitiveRelation.
+      def coordinate?
+        partitives.length >= 2
+      end
+
+      private
+
+      def validate_comprehensive!
+        return if comprehensive.is_a?(ConceptRef) &&
+                  (comprehensive.source || comprehensive.id || comprehensive.text)
+
+        raise ArgumentError,
+              "PartitiveRelation#comprehensive must be a non-empty " \
+              "ConceptRef (source, id, or text required)"
+      end
+
+      def validate_partitives!
+        if partitives.empty?
+          raise ArgumentError, "PartitiveRelation requires at least one partitive"
+        end
+        unless coordinate?
+          raise ArgumentError,
+                "PartitiveRelation requires ≥2 partitives (ISO 704); a single " \
+                "binary has_part edge should be used instead"
+        end
+
+        partitives.each(&:validate!)
+      end
+
+      def validate_self_loop!
+        return unless comprehensive.is_a?(ConceptRef)
+
+        comp_key = [comprehensive.source, comprehensive.id]
+        partitives.each do |member|
+          next unless member.ref.is_a?(ConceptRef)
+          next unless [member.ref.source, member.ref.id] == comp_key
+
+          raise ArgumentError,
+                "PartitiveRelation#partitives cannot include the comprehensive"
+        end
+      end
+
+      def validate_completeness!
+        return if completeness.nil?
+
+        unless Glossarist::GlossaryDefinition::COMPLETENESS_VALUES
+                 .include?(completeness)
+          raise ArgumentError,
+                "PartitiveRelation#completeness has invalid value " \
+                "#{completeness.inspect}; must be one of " \
+                "#{GlossaryDefinition::COMPLETENESS_VALUES.join(', ')}"
+        end
+      end
+
+      def validate_plurality!
+        plurality&.validate!
+      end
+    end
+  end
+end

data/lib/glossarist/v3/type_shared_plurality.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    # TypeSharedPlurality — semantic claims encoded by ISO 704's
+    # close-set double line and broken line notation, promoted from
+    # diagram-notation flags to structured data so tools can reason
+    # about plurality directly.
+    #
+    # A PartitiveRelation has at most one TypeSharedPlurality block.
+    # Absent means: no type-shared plurality claim is being made.
+    #
+    # Replaces the prior `markers` field (which encoded the same
+    # information as opaque strings like "double" and "dashed").
+    class TypeSharedPlurality < Lutaml::Model::Serializable
+      attribute :is_shared, :boolean
+      attribute :is_uncertain, :boolean, default: -> { false }
+      attribute :shared_type, ConceptRef
+
+      key_value do
+        map :is_shared, to: :is_shared
+        map :is_uncertain, to: :is_uncertain
+        map :shared_type, to: :shared_type
+      end
+
+      def validate!
+        unless is_shared.is_a?(TrueClass) || is_shared.is_a?(FalseClass)
+          raise ArgumentError,
+                "TypeSharedPlurality#is_shared is required (boolean)"
+        end
+
+        if is_uncertain == true && is_shared == false
+          raise ArgumentError,
+                "TypeSharedPlurality#is_uncertain requires is_shared: true " \
+                "(ISO 704 broken line qualifies the close-set double line claim)"
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/glossarist/v3.rb

@@ -9,6 +9,9 @@ module Glossarist
     autoload :DetailedDefinition, "glossarist/v3/detailed_definition"
     autoload :ConceptRef, "glossarist/v3/concept_ref"
     autoload :RelatedConcept, "glossarist/v3/related_concept"
+    autoload :PartitiveRelation, "glossarist/v3/partitive_relation"
+    autoload :PartitiveMember, "glossarist/v3/partitive_member"
+    autoload :TypeSharedPlurality, "glossarist/v3/type_shared_plurality"
     autoload :ConceptData, "glossarist/v3/concept_data"
     autoload :LocalizedConcept, "glossarist/v3/localized_concept"
     autoload :ManagedConceptData, "glossarist/v3/managed_concept_data"
@@ -23,6 +26,9 @@ module Glossarist
     Configuration.register_model(LocalizedConcept, id: :localized_concept)
     Configuration.register_model(ConceptRef, id: :concept_ref)
     Configuration.register_model(RelatedConcept, id: :related_concept)
+    Configuration.register_model(PartitiveRelation, id: :partitive_relation)
+    Configuration.register_model(PartitiveMember, id: :partitive_member)
+    Configuration.register_model(TypeSharedPlurality, id: :type_shared_plurality)
     Configuration.register_model(ManagedConceptData, id: :managed_concept_data)
     Configuration.register_model(ManagedConcept, id: :managed_concept)
     Configuration.register_model(ConceptDocument, id: :concept_document)

data/lib/glossarist/validation/rules/partitive_relation_rule.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      # Validates semantic invariants of PartitiveRelation entries
+      # that the model constructor does NOT enforce. Specifically:
+      #
+      #   - error when a relation has fewer than 2 partitives
+      #     (ISO 704: "two or more"; single binary should use
+      #     has_part edge instead)
+      #   - error when two relations share the same comprehensive
+      #     AND the same non-nil criterion (duplicate decomposition;
+      #     ISO 12620 coordinate-concept coherence)
+      #   - warning when a relation has no criterion (cannot
+      #     distinguish from siblings sharing the comprehensive)
+      #   - error when plurality.is_uncertain is set without
+      #     plurality.is_shared: true (broken-line qualifies
+      #     close-set double line)
+      #   - error when ExternalConcept (status: external) lacks
+      #     at least one designation
+      #
+      # The model constructor already rejects empty comprehensive,
+      # empty partitives list, self-loops, invalid enum values.
+      class PartitiveRelationRule < Base
+        def code = "GLS-221"
+        def category = :schema
+        def severity = "error"
+        def scope = :concept
+
+        def applicable?(context)
+          concept = context.concept
+          return false unless concept.is_a?(V3::ManagedConcept)
+
+          concept.partitive_relations&.any? || external?(concept)
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          return issues unless concept.is_a?(V3::ManagedConcept)
+
+          relations = Array(concept.partitive_relations)
+
+          relations.each_with_index do |rel, idx|
+            check_cardinality(rel, idx, fname, issues)
+            check_criterion_present(rel, idx, fname, issues)
+            check_plurality_coherence(rel, idx, fname, issues)
+          end
+
+          check_duplicate_decomposition(relations, fname, issues)
+          check_external_concept(concept, fname, issues)
+
+          issues
+        end
+
+        private
+
+        def external?(concept)
+          concept.status == "external"
+        end
+
+        def check_cardinality(rel, idx, fname, issues)
+          return if rel.partitives.length >= 2
+
+          issues << issue(
+            "partitive_relation #{idx + 1} has fewer than 2 partitives " \
+            "(ISO 704 requires two or more); a single binary has_part edge " \
+            "should be used instead",
+            location: fname,
+          )
+        end
+
+        def check_criterion_present(rel, idx, fname, issues)
+          return if rel.criterion && !rel.criterion.empty?
+
+          issues << issue(
+            "partitive_relation #{idx + 1} has no criterion; cannot verify " \
+            "distinctness from sibling relations sharing the comprehensive " \
+            "(ISO 12620 coordinate-concept coherence)",
+            severity: "warning",
+            location: fname,
+            suggestion: "Add a criterion: { eng: '...' } field",
+          )
+        end
+
+        def check_plurality_coherence(rel, idx, fname, issues)
+          plural = rel.plurality
+          return unless plural
+          return unless plural.is_uncertain
+          return if plural.is_shared
+
+          issues << issue(
+            "partitive_relation #{idx + 1}.plurality: is_uncertain requires " \
+            "is_shared: true (ISO 704 broken line qualifies the close-set " \
+            "double line claim)",
+            location: fname,
+          )
+        end
+
+        def check_duplicate_decomposition(relations, fname, issues)
+          grouped = {}
+          relations.each_with_index do |rel, idx|
+            next unless rel.criterion && !rel.criterion.empty?
+
+            key = criterion_key(rel)
+            (grouped[key] ||= []) << idx
+          end
+
+          grouped.each do |key, idxs|
+            next if idxs.length == 1
+
+            issues << issue(
+              "duplicate PartitiveRelation for comprehensive " \
+              "#{key.first.inspect} with criterion #{key.last.inspect} " \
+              "(relations ##{idxs.map { |i| i + 1 }.join(', ')}); " \
+              "two relations sharing comprehensive AND criterion are the " \
+              "same decomposition",
+              location: fname,
+            )
+          end
+        end
+
+        def criterion_key(rel)
+          comp = rel.comprehensive
+          comp_id = comp.is_a?(ConceptRef) ? [comp.source, comp.id] : nil
+          [comp_id, rel.criterion]
+        end
+
+        def check_external_concept(concept, fname, issues)
+          return unless external?(concept)
+
+          has_designation = concept.localizations.any? do |_, lc|
+            lc.is_a?(LocalizedConcept) && lc.terms&.any?
+          end
+
+          return if has_designation
+
+          issues << issue(
+            "ExternalConcept (status: external) must have at least one " \
+            "designation — even external concepts have a name",
+            location: fname,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/version.rb

@@ -4,5 +4,5 @@
 #
 
 module Glossarist
-  VERSION = "2.12.0"
+  VERSION = "2.13.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glossarist
 version: !ruby/object:Gem::Version
-  version: 2.12.0
+  version: 2.13.0
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-15 00:00:00.000000000 Z
+date: 2026-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -310,9 +310,12 @@ files:
 - lib/glossarist/rdf/gloss_locality.rb
 - lib/glossarist/rdf/gloss_localized_concept.rb
 - lib/glossarist/rdf/gloss_non_verbal_rep.rb
+- lib/glossarist/rdf/gloss_partitive_member.rb
+- lib/glossarist/rdf/gloss_partitive_relation.rb
 - lib/glossarist/rdf/gloss_pronunciation.rb
 - lib/glossarist/rdf/gloss_reference.rb
 - lib/glossarist/rdf/gloss_table.rb
+- lib/glossarist/rdf/gloss_type_shared_plurality.rb
 - lib/glossarist/rdf/localized_literal.rb
 - lib/glossarist/rdf/lutaml_ext.rb
 - lib/glossarist/rdf/namespaces.rb
@@ -394,7 +397,10 @@ files:
 - lib/glossarist/v3/localized_concept.rb
 - lib/glossarist/v3/managed_concept.rb
 - lib/glossarist/v3/managed_concept_data.rb
+- lib/glossarist/v3/partitive_member.rb
+- lib/glossarist/v3/partitive_relation.rb
 - lib/glossarist/v3/related_concept.rb
+- lib/glossarist/v3/type_shared_plurality.rb
 - lib/glossarist/validation.rb
 - lib/glossarist/validation/asset_index.rb
 - lib/glossarist/validation/bibliography_index.rb
@@ -436,6 +442,7 @@ files:
 - lib/glossarist/validation/rules/orphaned_bibliography_rule.rb
 - lib/glossarist/validation/rules/orphaned_images_rule.rb
 - lib/glossarist/validation/rules/orphaned_l10n_files_rule.rb
+- lib/glossarist/validation/rules/partitive_relation_rule.rb
 - lib/glossarist/validation/rules/preferred_term_rule.rb
 - lib/glossarist/validation/rules/ref_shape_rule.rb
 - lib/glossarist/validation/rules/registry.rb