glossarist 2.13.6 → 2.13.8

data/lib/glossarist/v3/hyperedge_member.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    # HyperedgeMember — abstract base shape for members of any
+    # n-ary concept-system hyperedge (PartitiveMember, GenericMember,
+    # future AssociativeMember, SequentialMember).
+    #
+    # Carries the shared ISO 704:2022 MECE dimensions on every member:
+    #   presence — required (default) | optional
+    #   count    — exactly_one (default) | at_least_one | multiple
+    #
+    # Type-specific extensions live on the leaves:
+    #   PartitiveMember — `is_delimiting` (Boolean): per ISO 704
+    #     §5.5.4.2.2, a part is or is not a delimiting part. Binary role.
+    #   GenericMember — `characteristic` (LocalizedString): per ISO 704
+    #     §5.5.4.2.1, each species carries a delimiting characteristic
+    #     text (e.g., "detecting movement by means of light sensors")
+    #     that distinguishes it from coordinate concepts under the
+    #     hyperedge's criterion of subdivision.
+    #
+    # The combination (optional, at_least_one) is invalid and collapses
+    # to (optional, multiple). Multiplicity is the SSOT for the
+    # validation; this class delegates to it.
+    class HyperedgeMember < Lutaml::Model::Serializable
+      DEFAULT_PRESENCE = "required"
+      DEFAULT_COUNT = "exactly_one"
+
+      attribute :ref, ConceptRef
+      attribute :presence, :string,
+                values: Glossarist::GlossaryDefinition::MEMBER_PRESENCE_VALUES,
+                default: -> { DEFAULT_PRESENCE }
+      attribute :count, :string,
+                values: Glossarist::GlossaryDefinition::MEMBER_COUNT_VALUES,
+                default: -> { DEFAULT_COUNT }
+
+      key_value do
+        map :ref, to: :ref
+        map :presence, to: :presence
+        map :count, to: :count
+      end
+
+      def initialize(*)
+        if instance_of?(HyperedgeMember)
+          raise NotImplementedError,
+                "HyperedgeMember is abstract; instantiate " \
+                "PartitiveMember or GenericMember instead"
+        end
+
+        super
+      end
+
+      def validate!
+        validate_ref!
+        validate_presence_count!
+        self
+      end
+
+      def required?
+        presence == "required"
+      end
+
+      def optional?
+        presence == "optional"
+      end
+
+      private
+
+      def validate_ref!
+        return if ref.is_a?(ConceptRef) && (ref.source || ref.id || ref.text)
+
+        raise ArgumentError,
+              "#{self.class.name}#ref must be a non-empty ConceptRef " \
+              "(source, id, or text required)"
+      end
+
+      # Delegates the MECE combination check to Multiplicity (the SSOT).
+      # Multiplicity.multiplicity_from_pair raises ArgumentError on the
+      # invalid (optional + at_least_one) combo with the canonical message.
+      # The returned name is discarded — only the validation side matters.
+      def validate_presence_count!
+        unless Glossarist::GlossaryDefinition::MEMBER_PRESENCE_VALUES
+            .include?(presence)
+          raise ArgumentError,
+                "#{self.class.name}#presence has invalid value " \
+                "#{presence.inspect}; must be one of " \
+                "#{GlossaryDefinition::MEMBER_PRESENCE_VALUES.join(', ')}"
+        end
+
+        unless Glossarist::GlossaryDefinition::MEMBER_COUNT_VALUES
+            .include?(count)
+          raise ArgumentError,
+                "#{self.class.name}#count has invalid value " \
+                "#{count.inspect}; must be one of " \
+                "#{GlossaryDefinition::MEMBER_COUNT_VALUES.join(', ')}"
+        end
+
+        Multiplicity.multiplicity_from_pair(presence, count)
+      end
+    end
+  end
+end

data/lib/glossarist/v3/hyperedge_registry.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    # HyperedgeRegistry — single SSOT for hyperedge-class lookup by
+    # every external identifier (wire key, type tag, RDF type).
+    #
+    # Auto-populates on class inheritance via AbstractHyperedge.inherited.
+    # Concrete leaves declare WIRE_KEY / TYPE_TAG / RDF_TYPE constants
+    # in a per-class metadata block; the registry reads them once at
+    # registration time.
+    #
+    # Adding a new hyperedge type means declaring one leaf class with
+    # the metadata block. No edit to any other file (parser, serializer,
+    # validator, RDF emitter, RelationLoader) — they all iterate or
+    # resolve through this registry.
+    module HyperedgeRegistry
+      # rubocop:disable Style/MutableConstant — these MUST stay
+      # mutable; register() adds entries at load time.
+      BY_WIRE_KEY = {}
+      BY_TYPE_TAG = {}
+      BY_RDF_TYPE = {}
+      # rubocop:enable Style/MutableConstant
+
+      Mutex = ::Mutex.new
+
+      class << self
+        # Register a concrete hyperedge class. Idempotent.
+        def register(cls)
+          return if cls.nil? || cls.const_defined?(:WIRE_KEY) == false
+
+          Mutex.synchronize do
+            wire = cls::WIRE_KEY
+            tag  = cls::TYPE_TAG
+            rdf  = cls::RDF_TYPE
+
+            BY_WIRE_KEY[wire] = cls unless wire.nil? || wire.empty?
+            BY_TYPE_TAG[tag]  = cls unless tag.nil? || tag.empty?
+            BY_RDF_TYPE[rdf]  = cls unless rdf.nil? || rdf.empty?
+          end
+        end
+
+        # Iterate every concrete leaf (use this in parser / serializer
+        # / loader to stay type-blind).
+        def all_classes
+          BY_TYPE_TAG.values.uniq
+        end
+
+        def for_wire_key(key)
+          BY_WIRE_KEY[key]
+        end
+
+        def for_type_tag(tag)
+          BY_TYPE_TAG[tag]
+        end
+
+        def for_rdf_type(rdf_type)
+          BY_RDF_TYPE[rdf_type]
+        end
+
+        # Reset (spec helper — never call from production code).
+        def reset!
+          Mutex.synchronize do
+            BY_WIRE_KEY.clear
+            BY_TYPE_TAG.clear
+            BY_RDF_TYPE.clear
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/v3/hyperedge_writer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+require "pathname"
+
+module Glossarist
+  module V3
+    # HyperedgeWriter — the WRITE half of per-file hyperedge storage.
+    #
+    # Mirror of RelationLoader. Each hyperedge is serialized to
+    # `relations/<comprehensive-id>/<criterion-slug>.yaml` with the
+    # full per-file wire format ($id, type, comprehensive, members,
+    # criterion, sources, notes, status, completeness).
+    #
+    # Per-file storage means a single concept (e.g., OIML 5.1
+    # measurement standard) can have N hyperedges (one per criterion),
+    # each in its own file under relations/<comp-id>/.
+    class HyperedgeWriter
+      class WriteError < ::StandardError
+      end
+
+      class << self
+        # Write a single hyperedge to its per-file location under
+        # `relations_dir`. Creates the comprehensive-id subdirectory
+        # if missing. Returns the absolute path written.
+        def write(hyperedge, relations_dir)
+          new(relations_dir).write(hyperedge)
+        end
+
+        # Write a batch of hyperedges. Returns an Array<String> of
+        # paths written. Hyperedges with the same comprehensive are
+        # written to the same subdirectory.
+        def write_all(hyperedges, relations_dir)
+          new(relations_dir).write_all(hyperedges)
+        end
+      end
+
+      def initialize(relations_dir)
+        @relations_dir = Pathname.new(relations_dir)
+      end
+
+      def write(hyperedge)
+        raise WriteError, "not an AbstractHyperedge: #{hyperedge.class}" unless
+          hyperedge.is_a?(AbstractHyperedge)
+
+        path = hyperedge.file_path(@relations_dir)
+        unless path
+          raise WriteError,
+                "cannot derive file path — comprehensive must be non-empty"
+        end
+
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, serialize(hyperedge))
+        path
+      end
+
+      def write_all(hyperedges)
+        Array(hyperedges).map { |h| write(h) }
+      end
+
+      private
+
+      # Serialize with stable key ordering: $id, type, status,
+      # comprehensive, members, completeness, criterion, sources,
+      # notes. Matches the concept-model per-file format.
+      def serialize(hyperedge)
+        hash = hyperedge.to_hash
+        hash["$id"] = hyperedge.file_id || hyperedge.derived_file_id
+        hash["type"] = hyperedge.class::TYPE_TAG
+        # Re-order for stable output.
+        ordered = {}
+        ordered["$id"]         = hash.delete("$id")
+        ordered["type"]        = hash.delete("type")
+        ordered["status"]      = hash.delete("status") if hash.key?("status")
+        ordered["comprehensive"] = hash.delete("comprehensive")
+        ordered["members"] = hash.delete("members")
+        ordered["completeness"] = hash.delete("completeness") if hash.key?("completeness")
+        ordered["criterion"]   = hash.delete("criterion") if hash.key?("criterion")
+        ordered["sources"]     = hash.delete("sources") if hash.key?("sources")
+        ordered["notes"]       = hash.delete("notes") if hash.key?("notes")
+        ordered.merge!(hash) # any future fields append in declaration order
+        ordered.compact!
+
+        YAML.dump(ordered).gsub(/^---\s*\n/, "---\n")
+      end
+    end
+  end
+end

data/lib/glossarist/v3/managed_concept.rb

@@ -2,18 +2,41 @@
 
 module Glossarist
   module V3
+    # V3 ManagedConcept.
+    #
+    # V3 storage model:
+    # - Concept metadata lives here on the concept (data, related,
+    #   dates, sources, status).
+    # - Hyperedges (PartitiveHyperedge, GenericHyperedge) are PER-FILE:
+    #   stored at relations/<comprehensive-id>/<criterion-slug>.yaml
+    #   and loaded via Glossarist::V3::RelationLoader. They are NOT
+    #   serialized inline on the concept YAML.
+    #
+    # This is the v3 clean break — the bundled format
+    # (`partitive_relations: [...]` inline on the concept YAML) is
+    # removed. Concept-model removed it without backward compat in
+    # commit a62cf85; ruby aligns.
+    #
+    # #relations is the unified accessor. The list is populated by
+    # callers (GlossaryStore#relations_for, RelationLoader, direct
+    # construction). NO typed projections — callers filter:
+    #
+    #   concept.relations.select { |r| r.is_a?(PartitiveHyperedge) }
+    #   concept.relations.select { |r| r.comprehensive.id == my_id }
     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
 
+      # Unified hyperedge accessor. NOT serialized (per-file storage);
+      # populated externally by GlossaryStore / RelationLoader.
+      attribute :relations, V3::AbstractHyperedge, collection: true
+
       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 }
@@ -22,6 +45,7 @@ module Glossarist
                          with: { from: :uuid_from_yaml, to: :uuid_to_yaml }
         map :schema_version, to: :schema_version
         map :sources, to: :sources
+        # relations: intentionally NOT mapped — per-file storage only.
       end
 
       def date_accepted_from_yaml(model, value)
@@ -29,6 +53,33 @@ module Glossarist
           { "date" => value, "type" => "accepted" },
         )
       end
+
+      # Strict setter — rejects duplicates by identity (type +
+      # comprehensive + criterion fingerprint). Adding the same
+      # hyperedge twice is always a bug; dedupe hides bugs.
+      def relations=(list)
+        seen = {}
+        Array(list).each do |rel|
+          key = hyperedge_identity(rel)
+          if seen[key]
+            raise ArgumentError,
+                  "duplicate hyperedge #{key.inspect} — pass each " \
+                  "decomposition once"
+          end
+          seen[key] = rel
+        end
+        super(seen.values)
+      end
+
+      private
+
+      def hyperedge_identity(rel)
+        return rel.object_id.to_s unless rel.is_a?(V3::AbstractHyperedge)
+
+        comp = Glossarist::ConceptRef.qualified_id(rel.comprehensive)
+        crit = rel.criterion.is_a?(Hash) ? rel.criterion.sort.to_h : rel.criterion
+        "#{rel.class}:#{comp}:#{crit}"
+      end
     end
   end
 end

data/lib/glossarist/v3/managed_concept_data.rb

@@ -47,4 +47,3 @@ module Glossarist
     end
   end
 end
-

data/lib/glossarist/v3/partitive_hyperedge.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    # PartitiveHyperedge — an ISO 704 / ISO 1087-1 / ISO 12620 partitive
+    # hyperedge connecting a comprehensive concept (superordinate concept
+    # partitive) to two or more partitive concepts (subordinate concepts
+    # partitive) which fitted together constitute the comprehensive.
+    #
+    # Inherits structure and validations from AbstractHyperedge.
+    # The `comprehensive` field denotes the whole concept.
+    #
+    # Per-file storage: lives at
+    # relations/<comprehensive-id>/<criterion-slug>.yaml — see
+    # docs/design/relations-as-files.md (concept-model repo).
+    #
+    # The `key_value` mapping is inherited from AbstractHyperedge
+    # (single SSOT). Only the typed member collection is narrowed here.
+    #
+    # Per-class metadata block — the SSOT for this leaf's external
+    # identifiers. Adding a new hyperedge type means declaring a new
+    # class with an equivalent block; no other file needs editing
+    # (parsers, serializers, validators, RDF emitters, and the loader
+    # all dispatch through HyperedgeRegistry by these constants).
+    class PartitiveHyperedge < AbstractHyperedge
+      # YAML key on Concept (legacy bundled-format wire name; kept for
+      # backward compat with concept-model).
+      WIRE_KEY = "partitive_relations"
+
+      # Per-file `type:` discriminator in relations/<id>/<slug>.yaml.
+      TYPE_TAG = "partitive_relation"
+
+      # RDF type URI (gloss: ontology — concept-model contract).
+      RDF_TYPE = "gloss:PartitiveRelation"
+
+      # Member class — narrows the parent's members: HyperedgeMember.
+      MEMBER_CLASS = PartitiveMember
+
+      # Legacy v1 wire keys that migrate to this class on parse.
+      V1_WIRE_KEYS = %w[partitive_hyperedges].freeze
+
+      # Short label for diff display ("PART" / "GEN" / etc.).
+      KIND_LABEL = "PART"
+
+      attribute :members, PartitiveMember, collection: true
+    end
+
+    # Auto-register with HyperedgeRegistry. Adding a new hyperedge
+    # type means adding a class with an equivalent block + this one
+    # register call — nothing else in the codebase changes.
+    HyperedgeRegistry.register(PartitiveHyperedge)
+  end
+end

data/lib/glossarist/v3/partitive_member.rb

@@ -2,51 +2,21 @@
 
 module Glossarist
   module V3
-    # PartitiveMember — one member of a PartitiveRelation, carrying
-    # a ConceptRef to the partitive concept plus ISO 704:2022
-    # multiplicity and delimiting metadata.
+    # PartitiveMember — one member of a PartitiveHyperedge. The
+    # `comprehensive` of its parent PartitiveHyperedge denotes the
+    # whole concept; this member denotes one of its parts.
     #
-    # ISO 704:2022 partitive member notation uses two orthogonal
-    # dimensions (MECE decomposition):
+    # Per ISO 704:2022 §5.5.4.2.2, a part is either delimiting or not:
+    # a delimiting part behaves like a delimiting characteristic — it
+    # distinguishes the comprehensive (whole) from coordinate concepts.
+    # Example: for "optomechanical mouse", the delimiting parts are
+    # mouse ball, x/y-axis rollers, infrared emitter/sensor — they
+    # distinguish it from "mechanical mouse" and "optical mouse".
+    # Mouse button is NOT delimiting (all computer mice have buttons).
     #
-    #   presence (line style — solid vs dashed):
-    #     required   — solid line (must exist in every instance)
-    #     optional   — dashed line (may exist; exists in some instances)
-    #
-    #   count (line count — how many):
-    #     exactly_one  — 1 line
-    #     at_least_one — 1 solid + 1 dashed
-    #     multiple     — 2 lines
-    #
-    # Valid combinations (5):
-    #   required + exactly_one    = compulsory (1 solid)
-    #   optional + exactly_one    = optional (1 dashed)
-    #   required + multiple       = compulsory_multiple (2 solid)
-    #   optional + multiple       = optional_multiple (2 dashed)
-    #   required + at_least_one   = compulsory_at_least_one (1 solid + 1 dashed)
-    #
-    # Invalid: optional + at_least_one (collapses to optional + multiple
-    # because "at least one, if present" = "zero or more" = optional_multiple).
-    #
-    # is_delimiting (orthogonal, bold 3x-width line in diagram):
-    #   A delimiting part behaves like a delimiting characteristic:
-    #   it distinguishes the comprehensive from coordinate concepts.
-    #   Example (ISO 704 §5.5.4.2.2): for "optomechanical mouse",
-    #   the delimiting parts are mouse ball, x/y-axis rollers,
-    #   infrared emitter/sensor — they distinguish it from
-    #   "mechanical mouse" and "optical mouse". Mouse button is
-    #   NOT delimiting (all computer mice have buttons).
-    class PartitiveMember < Lutaml::Model::Serializable
-      DEFAULT_PRESENCE = "required"
-      DEFAULT_COUNT = "exactly_one"
-
-      attribute :ref, ConceptRef
-      attribute :presence, :string,
-                values: Glossarist::GlossaryDefinition::PARTITIVE_PRESENCE_VALUES,
-                default: -> { DEFAULT_PRESENCE }
-      attribute :count, :string,
-                values: Glossarist::GlossaryDefinition::PARTITIVE_COUNT_VALUES,
-                default: -> { DEFAULT_COUNT }
+    # The binary role is sufficient — no per-member delimiting text is
+    # needed because the part itself IS the delimiting marker.
+    class PartitiveMember < HyperedgeMember
       attribute :is_delimiting, :boolean, default: -> { false }
 
       key_value do
@@ -56,58 +26,9 @@ module Glossarist
         map :is_delimiting, to: :is_delimiting
       end
 
-      def validate!
-        validate_ref!
-        validate_presence_count!
-        self
-      end
-
-      def required?
-        presence == "required"
-      end
-
-      def optional?
-        presence == "optional"
-      end
-
       def delimiting?
         is_delimiting == true
       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_presence_count!
-        unless Glossarist::GlossaryDefinition::PARTITIVE_PRESENCE_VALUES
-                 .include?(presence)
-          raise ArgumentError,
-                "PartitiveMember#presence has invalid value " \
-                "#{presence.inspect}; must be one of " \
-                "#{GlossaryDefinition::PARTITIVE_PRESENCE_VALUES.join(', ')}"
-        end
-
-        unless Glossarist::GlossaryDefinition::PARTITIVE_COUNT_VALUES
-                 .include?(count)
-          raise ArgumentError,
-                "PartitiveMember#count has invalid value " \
-                "#{count.inspect}; must be one of " \
-                "#{GlossaryDefinition::PARTITIVE_COUNT_VALUES.join(', ')}"
-        end
-
-        if presence == "optional" && count == "at_least_one"
-          raise ArgumentError,
-                "PartitiveMember presence=optional + count=at_least_one is " \
-                "invalid — it collapses to optional + multiple (zero or more). " \
-                "Use presence: optional, count: multiple instead."
-        end
-      end
     end
   end
 end

data/lib/glossarist/v3/relation_loader.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module Glossarist
+  module V3
+    # RelationLoader — scans a directory for per-file hyperedge files
+    # and returns typed instances.
+    #
+    # Files live at `relations/<comprehensive-id>/<criterion-slug>.yaml`.
+    # The `type` field on each file discriminates which concrete
+    # hyperedge class to instantiate. Dispatch is via HyperedgeRegistry
+    # — adding a new hyperedge type requires no edit here.
+    #
+    # Usage:
+    #   relations = RelationLoader.load_all("path/to/dataset/relations")
+    #   partitive = RelationLoader.load_for_concept("path/to/dataset", "5-1")
+    class RelationLoader
+      class LoadError < ::StandardError
+      end
+
+      class << self
+        # Load every relation file under `dir`. Returns a hash keyed
+        # by comprehensive id, value = array of typed hyperedges.
+        def load_all(dir)
+          new(dir).load_all
+        end
+
+        # Load all relation files for a single comprehensive id.
+        # `dataset_root` is the path containing the `relations/` directory.
+        def load_for_concept(dataset_root, comprehensive_id)
+          new(File.join(dataset_root, "relations")).load_for_comprehensive(comprehensive_id)
+        end
+
+        # Load a single relation file. Returns a typed hyperedge
+        # instance (PartitiveHyperedge, GenericHyperedge, etc.).
+        def load_file(path)
+          new(File.dirname(path, 2)).load_path(path)
+        end
+      end
+
+      def initialize(relations_dir)
+        @relations_dir = Pathname.new(relations_dir)
+      end
+
+      def load_all
+        each_relation_path.with_object({}) do |path, h|
+          rel = load_path(path)
+          comp_id = Glossarist::ConceptRef.qualified_id(rel.comprehensive)
+          (h[comp_id] ||= []) << rel
+        end
+      end
+
+      def load_for_comprehensive(comprehensive_id)
+        dir = @relations_dir.join(comprehensive_id.to_s)
+        return [] unless dir.exist?
+
+        Dir.glob("#{dir}/*.yaml").map { |p| load_path(Pathname.new(p)) }
+      end
+
+      def load_path(path)
+        path = Pathname.new(path)
+        doc = YAML.load_file(path)
+        unless doc.is_a?(Hash) && doc["type"]
+          raise LoadError, "#{path} missing required `type` field"
+        end
+
+        klass = HyperedgeRegistry.for_type_tag(doc["type"])
+        unless klass
+          known = HyperedgeRegistry.all_classes.map { |c| c::TYPE_TAG }.join(", ")
+          raise LoadError, "#{path} has unknown type #{doc['type'].inspect}; " \
+                           "expected one of #{known}"
+        end
+
+        # Preserve the source $id so round-trip writes go to the same
+        # file path. Without this, write-back would derive a new path
+        # from comprehensive + criterion and could fragment files.
+        file_id = doc["$id"]
+        instance = klass.from_hash(doc)
+        instance.file_id = file_id if file_id && instance.respond_to?(:file_id=)
+        instance
+      end
+
+      private
+
+      def each_relation_path
+        return enum_for(:each_relation_path) unless block_given?
+
+        return unless @relations_dir.exist?
+
+        Dir.glob("#{@relations_dir}/**/*.yaml").each do |p|
+          yield Pathname.new(p)
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/v3.rb

@@ -9,14 +9,17 @@ 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 :HyperedgeMember, "glossarist/v3/hyperedge_member"
+    autoload :AbstractHyperedge, "glossarist/v3/abstract_hyperedge"
+    autoload :HyperedgeRegistry, "glossarist/v3/hyperedge_registry"
+    autoload :HyperedgeIndex, "glossarist/v3/hyperedge_index"
+    autoload :PartitiveHyperedge, "glossarist/v3/partitive_hyperedge"
     autoload :PartitiveMember, "glossarist/v3/partitive_member"
-    # Multiplicity is a derived-view utility module (SSOT for the
-    # ISO 704:2022 (presence, count) → name mapping), not a Lutaml
-    # model — so it is autoloaded but NOT registered via
-    # Configuration.register_model. Used by renderers/viewers to
-    # display the ISO name; the PartitiveMember model itself only
-    # carries the orthogonal presence + count dimensions.
+    autoload :GenericHyperedge, "glossarist/v3/generic_hyperedge"
+    autoload :GenericMember, "glossarist/v3/generic_member"
+    autoload :DefinitionType, "glossarist/v3/definition_type"
+    autoload :RelationLoader, "glossarist/v3/relation_loader"
+    autoload :HyperedgeWriter, "glossarist/v3/hyperedge_writer"
     autoload :Multiplicity, "glossarist/v3/multiplicity"
     autoload :ConceptData, "glossarist/v3/concept_data"
     autoload :LocalizedConcept, "glossarist/v3/localized_concept"
@@ -32,10 +35,24 @@ 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)
+    # HyperedgeMember and AbstractHyperedge are abstract base classes —
+    # they are NOT registered as Lutaml models because they must not be
+    # instantiable directly. Concrete leaves (PartitiveHyperedge,
+    # GenericHyperedge, PartitiveMember, GenericMember) are registered
+    # below and also auto-registered with HyperedgeRegistry.
+    Configuration.register_model(PartitiveHyperedge, id: :partitive_hyperedge)
     Configuration.register_model(PartitiveMember, id: :partitive_member)
+    Configuration.register_model(GenericHyperedge, id: :generic_hyperedge)
+    Configuration.register_model(GenericMember, id: :generic_member)
     Configuration.register_model(ManagedConceptData, id: :managed_concept_data)
     Configuration.register_model(ManagedConcept, id: :managed_concept)
     Configuration.register_model(ConceptDocument, id: :concept_document)
+
+    # Eager-load concrete hyperedge leaves so HyperedgeRegistry
+    # auto-populates via AbstractHyperedge.inherited. Without this,
+    # autoload defers leaf definition until first reference, leaving
+    # the registry empty at boot.
+    PartitiveHyperedge
+    GenericHyperedge
   end
 end