glossarist 2.13.6 → 2.13.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51ac508f50dca0e1c04b8a37fbb75460dc27496876321361b9e3691995b203dc
-  data.tar.gz: a41b2f29cfaca14931ee3035c751ad296065a0159b9bc202251e1775973f3ea8
+  metadata.gz: b4d7af45a5f0e045d0f3a18cdcca5791a85bfcb6a16a642af0c1e840b68ef6e8
+  data.tar.gz: 8fd502d531f3c862c340b3aa19bb1fc4e4b205e7217ba4c79ee6bc1809db0d35
 SHA512:
-  metadata.gz: 5a9a6b0040e89f986f676a2dbd4b8c86244c110fb4f3c005f9d5995f3bdf7abef50c48564c5d8551d11beca5f7876def2b8970ff719b086e091562f6ce3830ae
-  data.tar.gz: 4f81856d110124d519e3cbf10a5863623fe13b57283e89861ce1882c83d7fb1768c792c0f27e41b99c4cd7c462b00ce0a7dcfb894169c92985c4430c4fa8b84a
+  metadata.gz: aedc22ebce41ec42d6bc93e96abef82078b7834b66f08a0e219b08f4b2e0eded91561bcc82af7498ab50aed4e8da32d0cabc23c37b7eb56390ec7028e8b731ba
+  data.tar.gz: fe063d88bf1297f1c31e72ce545a9a9e32f7deb89f6d24cd6580572f830f605288e57feed04ed3af4ebb9c777320def6c5fc87e9ec82a93ef12c0a070a7f42b7

data/config.yml

@@ -234,3 +234,18 @@ multiplicity:
     - exactly_one
     - at_least_one
     - multiple
+
+definition_type:
+  # ISO 704:2022 §5.3 definition strategies.
+  # See docs/design/definition-types.md (in concept-model repo).
+  value:
+    - intensional
+    - extensional
+    - partitive
+    - translated
+
+relation_type:
+  # Wire discriminator for per-file n-ary relation files.
+  value:
+    - partitive_relation
+    - generic_relation

data/lib/glossarist/cli/export_command.rb

@@ -154,7 +154,7 @@ module Glossarist
       def export_jsonld(concepts, name, output_dir)
         require "glossarist/transforms/concept_to_gloss_transform"
         transform = Transforms::ConceptToGlossTransform.new(nil,
-                                                            transform_options)
+                                                            **transform_options)
         File.write(File.join(output_dir, "#{name}.jsonld"),
                    transform.to_jsonld(concepts,
                                        figures: dataset_figures,
@@ -165,7 +165,7 @@ module Glossarist
       def export_turtle(concepts, name, output_dir)
         require "glossarist/transforms/concept_to_gloss_transform"
         transform = Transforms::ConceptToGlossTransform.new(nil,
-                                                            transform_options)
+                                                            **transform_options)
         File.write(File.join(output_dir, "#{name}.ttl"),
                    transform.to_turtle(concepts,
                                        figures: dataset_figures,
@@ -185,7 +185,7 @@ module Glossarist
         File.open(File.join(output_dir, "#{name}.jsonl"), "w") do |f|
           concepts.each do |concept|
             transform = Transforms::ConceptToGlossTransform.new(concept,
-                                                                transform_options)
+                                                                **transform_options)
             f.write(transform.to_jsonl_line)
             f.write("\n")
           end
@@ -223,7 +223,7 @@ module Glossarist
         concepts.each do |concept|
           id = concept.data&.id || concept.identifier
           transform = Transforms::ConceptToGlossTransform.new(concept,
-                                                              transform_options)
+                                                              **transform_options)
           File.write(File.join(dir, "#{id}.jsonld"), transform.to_jsonld)
         end
       end
@@ -233,7 +233,7 @@ module Glossarist
         concepts.each do |concept|
           id = concept.data&.id || concept.identifier
           transform = Transforms::ConceptToGlossTransform.new(concept,
-                                                              transform_options)
+                                                              **transform_options)
           File.write(File.join(dir, "#{id}.ttl"), transform.to_turtle)
         end
       end

data/lib/glossarist/concept_ref.rb

@@ -1,6 +1,18 @@
 # frozen_string_literal: true
 
 module Glossarist
+  # A typed reference to another concept, used inside n-ary relation
+  # members and other internal pointer shapes.
+  #
+  # The base ConceptRef carries `source`, `id`, and `text`. The richer
+  # `ConceptReference` (in `glossarist/concept_reference.rb`) extends
+  # this with `term`, `urn`, `version`, `ref_type` for use in
+  # cross-vocabulary references and relevance contexts.
+  #
+  # A ConceptRef is identified by `source:id` for external references
+  # or just `id` for local references. The `qualified_id` class method
+  # is the single SSOT for this string format — used by RelationLoader,
+  # the RDF transform, and ConceptRef-bearing data structures.
   class ConceptRef < Lutaml::Model::Serializable
     attribute :source, :string
     attribute :id, :string
@@ -11,5 +23,42 @@ module Glossarist
       map :id, to: :id
       map :text, to: :text
     end
+
+    # SSOT for the canonical "qualified identifier" string of a
+    # ConceptRef. Returns:
+    #
+    #   - "{source}:{id}"         when both source and id are present
+    #   - "{id}"                  when only id is present (local ref)
+    #   - "{source}:{text}"       when source and text are present (no id)
+    #   - "{text}"                when only text is present (external
+    #                             concept form, no resolvable id)
+    #   - nil                     when the ref is empty / not a ConceptRef
+    #
+    # Two refs are considered to point at the same concept iff their
+    # qualified_id is equal. Tables and registries can use this
+    # directly as a hash key.
+    def self.qualified_id(ref)
+      return nil unless ref.is_a?(ConceptRef)
+
+      id_part = (ref.id.to_s.empty? ? nil : ref.id)
+      text_part = (ref.text.to_s.empty? ? nil : ref.text)
+      source_part = (ref.source.to_s.empty? ? nil : ref.source)
+
+      if id_part
+        source_part ? "#{source_part}:#{id_part}" : id_part
+      elsif text_part
+        source_part ? "#{source_part}:#{text_part}" : text_part
+      end
+    end
+
+    # Per-instance convenience delegating to the class method.
+    def qualified_id
+      self.class.qualified_id(self)
+    end
+
+    # True iff +other+ refers to the same concept as self.
+    def same_concept?(other)
+      qualified_id == self.class.qualified_id(other)
+    end
   end
 end

data/lib/glossarist/gcr_package.rb

@@ -228,7 +228,7 @@ module Glossarist
       require "glossarist/transforms/concept_to_gloss_transform"
 
       if formats.include?("jsonld") || formats.include?("turtle")
-        transform = Transforms::ConceptToGlossTransform.new(nil, opts)
+        transform = Transforms::ConceptToGlossTransform.new(nil, **opts)
 
         if formats.include?("jsonld")
           zip_file.get_output_stream("compiled/#{name}.jsonld") do |f|
@@ -247,7 +247,7 @@ module Glossarist
 
       zip_file.get_output_stream("compiled/#{name}.jsonl") do |f|
         concepts.each do |concept|
-          transform = Transforms::ConceptToGlossTransform.new(concept, opts)
+          transform = Transforms::ConceptToGlossTransform.new(concept, **opts)
           f.write(transform.to_jsonl_line)
           f.write("\n")
         end

data/lib/glossarist/gcr_validator.rb

@@ -4,8 +4,19 @@ require "zip"
 
 module Glossarist
   class GcrValidator
-    def initialize(on_progress: nil)
+    # N-ary relations live in per-file relation store (see
+    # Glossarist::V3::RelationLoader), not inside the GCR. For GCR
+    # validation, callers can pass a `relations:` hash keyed by
+    # concept_id; the validator passes the per-concept list to each
+    # concept's context. Without it, relations are not validated
+    # here — only the concepts themselves.
+    def initialize(on_progress: nil, relations: nil)
       @on_progress = on_progress
+      @relations = relations
+    end
+
+    def self.validate(zip_path, relations: nil, **opts)
+      new(**opts, relations: relations).validate(zip_path)
     end
 
     def validate(zip_path)
@@ -58,6 +69,7 @@ module Glossarist
           concept,
           file_name: concept.data&.id ? "concepts/#{concept.data.id}.yaml" : "concepts/concept-#{idx}.yaml",
           collection_context: context,
+          relations: relations_for_concept(concept),
         )
 
         concept_rules.each do |rule|
@@ -70,6 +82,12 @@ module Glossarist
       end
     end
 
+    def relations_for_concept(concept)
+      return [] unless @relations
+
+      @relations[concept.data&.id] || []
+    end
+
     def validate_collection(context, result)
       Validation::Rules::Registry.for_scope(:collection).each do |rule|
         next unless rule.applicable?(context)

data/lib/glossarist/glossary_definition.rb

@@ -34,13 +34,26 @@ module Glossarist
 
     ISO12620_TERM_TYPES = config.dig("iso12620", "term_type").freeze
 
-    # PartitiveRelation redesign (TODO.partitive-relation-v2).
+    # PartitiveHyperedge redesign (TODO.partitive-relation-v2).
     COMPLETENESS_VALUES = config.dig("completeness", "value").freeze
 
-    PARTITIVE_PRESENCE_VALUES =
+    # Member presence/count values for any n-ary relation member
+    # (PartitiveMember, GenericMember — both inherit HyperedgeMember).
+    # The config key is `multiplicity:` because presence + count encode
+    # ISO 704:2022 multiplicity in the MECE decomposition; the constants
+    # are named for their consumers (HyperedgeMember fields).
+    MEMBER_PRESENCE_VALUES =
       config.dig("multiplicity", "presence").freeze
 
-    PARTITIVE_COUNT_VALUES =
+    MEMBER_COUNT_VALUES =
       config.dig("multiplicity", "count").freeze
+
+    # ISO 704:2022 §5.3 definition strategies.
+    DEFINITION_TYPE_VALUES =
+      config.dig("definition_type", "value").freeze
+
+    # Wire discriminator for per-file n-ary relation files.
+    RELATION_TYPE_VALUES =
+      config.dig("relation_type", "value").freeze
   end
 end

data/lib/glossarist/glossary_store.rb

@@ -78,10 +78,43 @@ module Glossarist
     def save_directory(path, format: nil, formats: {})
       @package.save(path, transport: :directory, format: format,
                           formats: formats)
+      # Persist per-file hyperedges alongside concepts. The relations/
+      # subdirectory mirrors the load path (relations/<comp-id>/<slug>.yaml).
+      save_relations(File.join(path, "relations")) if @relations && !@relations.empty?
     end
 
     def save_zip(path, format: nil, formats: {})
       @package.save(path, transport: :zip, format: format, formats: formats)
+      # ZIP transport doesn't expose a writable filesystem path here —
+      # callers persisting to ZIP must use #save_relations separately
+      # against a staging dir before zipping. Documented limitation.
+    end
+
+    # Persist all loaded relations to the per-file store under `dir`.
+    # Each hyperedge becomes relations/<comp-id>/<slug>.yaml (one file
+    # per hyperedge, per concept-model per-file format).
+    def save_relations(dir)
+      return if @relations.nil? || @relations.empty?
+
+      V3::HyperedgeWriter.write_all(@relations, dir)
+    end
+
+    # Add a hyperedge to the in-memory list AND persist it immediately
+    # to its per-file location under <dataset_path>/relations/.
+    # Returns the written file path (or nil if dataset has no path).
+    def add_relation(hyperedge)
+      (@relations ||= []) << hyperedge
+      return nil unless @dataset_path
+
+      relations_dir = File.join(@dataset_path, "relations")
+      V3::HyperedgeWriter.write(hyperedge, relations_dir)
+    end
+
+    # Remove a hyperedge. Caller-supplied predicate selects which to
+    # remove. The per-file storage is NOT modified by this method —
+    # use #delete_relation_file to remove a single file.
+    def remove_relations_if(&predicate)
+      @relations&.reject!(&predicate)
     end
 
     # ── Concepts ──
@@ -202,6 +235,30 @@ module Glossarist
       @formulas ||= load_dataset_entities("formulas", Formula)
     end
 
+    # Per-file n-ary relations (PartitiveHyperedge, GenericHyperedge)
+    # discovered under `relations/<comprehensive-id>/<criterion-slug>.yaml`.
+    # Returns a flat Array<AbstractHyperedge>; use #relations_for to
+    # filter by comprehensive id. Empty when the dataset has no
+    # relations/ directory (V1/V2 datasets, or V3 datasets that only
+    # carry concepts).
+    def relations
+      @relations ||= load_relations
+    end
+
+    # Relations whose comprehensive concept matches `qualified_id`
+    # (e.g. "VIM:112-02-09"). Accepts either a qualified-id string or
+    # a ConceptRef — the lookup goes through ConceptRef.qualified_id.
+    def relations_for(qualified_id_or_ref)
+      target = if qualified_id_or_ref.is_a?(Glossarist::ConceptRef)
+                 Glossarist::ConceptRef.qualified_id(qualified_id_or_ref)
+               else
+                 qualified_id_or_ref.to_s
+               end
+      relations.select do |rel|
+        Glossarist::ConceptRef.qualified_id(rel.comprehensive) == target
+      end
+    end
+
     # ── Stats ──
 
     def stats
@@ -244,6 +301,19 @@ module Glossarist
       end
     end
 
+    # Loads per-file n-ary relations via V3::RelationLoader. Returns a
+    # flat Array<AbstractHyperedge>. Empty when no relations/
+    # directory exists. The loader handles V1/V2 datasets gracefully
+    # (no relations directory → empty).
+    def load_relations
+      return [] unless @dataset_path
+
+      relations_dir = File.join(@dataset_path, "relations")
+      return [] unless File.directory?(relations_dir)
+
+      V3::RelationLoader.load_all(relations_dir).values.flatten
+    end
+
     def resolve_concept_document_class(metadata)
       version = metadata&.schema_version.to_s
       ConceptDocument.for_version(version)

data/lib/glossarist/managed_concept.rb

@@ -165,7 +165,7 @@ module Glossarist
       @uuid = new_uuid
     end
 
-    def self.detect_schema_version(concept) # rubocop:disable Metrics/PerceivedComplexity
+    def self.detect_schema_version(concept, relations: nil) # rubocop:disable Metrics/PerceivedComplexity
       raw = concept.schema_version
       if raw && !%w[legacy nil].include?(raw.to_s)
         return raw.to_s
@@ -175,7 +175,7 @@ module Glossarist
       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?
+        relations&.any?
       return "3" if localization_has_references?(concept)
 
       "2"

data/lib/glossarist/rdf/gloss_concept.rb

@@ -12,6 +12,7 @@ module Glossarist
       attribute :domains, GlossConceptReference, collection: true
       attribute :dates, GlossConceptDate, collection: true
       attribute :partitive_relations, GlossPartitiveRelation, collection: true
+      attribute :generic_relations, GlossGenericRelation, collection: true
 
       RelationshipPredicates::CONCEPT_REL_PREDICATES.each_key do |type|
         attribute :"#{type}_targets", :string, collection: true
@@ -44,6 +45,8 @@ module Glossarist
                 link: "gloss:hasDate"
         members :partitive_relations,
                 link: "gloss:hasPartitiveRelation"
+        members :generic_relations,
+                link: "gloss:hasGenericRelation"
 
         RelationshipPredicates::CONCEPT_REL_PREDICATES.each do |type, (ns, name)|
           predicate name, namespace: ns, to: :"#{type}_targets",

data/lib/glossarist/rdf/gloss_generic_member.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    # RDF view for V3::GenericMember. Inherits attributes and
+    # deterministic_id from GlossNaryMember. The `rdf do` block
+    # re-declares the predicates because lutaml-model's `rdf` DSL
+    # replaces the parent mapping (not extends).
+    class GlossGenericMember < GlossNaryMember
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |m| "genericMember/#{GlossGenericMember.deterministic_id(m)}" }
+
+        types "gloss:GenericMember"
+
+        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 :presence, namespace: Namespaces::GlossaristNamespace,
+                             to: :presence
+        predicate :count, namespace: Namespaces::GlossaristNamespace,
+                          to: :count
+        predicate :isDelimiting, namespace: Namespaces::GlossaristNamespace,
+                                 to: :is_delimiting
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_generic_relation.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    # RDF view for V3::GenericHyperedge. Inherits structure and
+    # helpers from GlossNaryRelation. The `rdf do` block re-declares
+    # the predicates because lutaml-model's `rdf` DSL replaces the
+    # parent mapping (not extends).
+    class GlossGenericRelation < GlossNaryRelation
+      attribute :generic_member_ids, :string, collection: true
+      attribute :generic_members, GlossGenericMember, collection: true
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |r| "genericRelation/#{GlossGenericRelation.deterministic_id(r)}" }
+
+        types "gloss:GenericHyperedge"
+
+        predicate :comprehensive, namespace: Namespaces::GlossaristNamespace,
+                                  to: :comprehensive_uri, uri_reference: true
+        predicate :hasGeneric, namespace: Namespaces::GlossaristNamespace,
+                               to: :generic_member_ids, uri_reference: true
+        predicate :completeness, namespace: Namespaces::GlossaristNamespace,
+                                 to: :completeness, uri_reference: true
+        predicate :criterion, namespace: Namespaces::GlossaristNamespace,
+                              to: :criterion
+
+        members :generic_members, link: "gloss:hasGenericMember"
+      end
+
+      def self.deterministic_id(rel)
+        parts = [rel.identifier, rel.comprehensive_uri, rel.completeness,
+                 criterion_fingerprint(rel.criterion)]
+        Array(rel.generic_members).each do |m|
+          parts << GlossGenericMember.deterministic_id(m)
+        end
+        DeterministicSlug.from_parts(*parts)
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_nary_member.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    # Shared base for typed n-ary relation member RDF views
+    # (GlossPartitiveMember, GlossGenericMember, future leaves).
+    #
+    # Carries the shared attributes and the deterministic_id algorithm.
+    # Concrete leaves declare their own `rdf do` block because
+    # lutaml-model's `rdf` DSL replaces (not extends) the parent's
+    # mapping — predicate declarations stay in each leaf.
+    #
+    # Subject identity is content-derived so the same member in the
+    # same relation produces the same URI across runs (and across
+    # processes). Two members with identical ref + dimensions share a
+    # subject — that is intentional: it exposes model-level
+    # inconsistency if the same partitive concept is given different
+    # dimensions inside the same dataset.
+    class GlossNaryMember < Lutaml::Model::Serializable
+      attribute :ref_id, :string
+      attribute :ref_source, :string
+      attribute :ref_text, :string
+      attribute :presence, :string
+      attribute :count, :string
+      attribute :is_delimiting, :boolean
+
+      # Human-readable SOURCE:ID when both are present; SHA-256 / 16
+      # hex chars fallback otherwise. Same content → same slug across
+      # instances, runs, and processes.
+      def self.deterministic_id(member)
+        readable = [member.ref_source, member.ref_id].compact.reject(&:empty?)
+        return readable.join(":") unless readable.empty?
+
+        DeterministicSlug.from_parts(
+          member.ref_source, member.ref_id, member.ref_text,
+          member.presence, member.count, member.is_delimiting
+        )
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_nary_relation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    # Shared base for typed n-ary relation RDF views
+    # (GlossPartitiveRelation, GlossGenericRelation, future leaves).
+    #
+    # Concrete leaves override the `rdf do` block to declare their
+    # type-specific subject prefix, `types` declaration, member-class
+    # attribute, and link predicate name. The deterministic_id and
+    # criterion_fingerprint algorithms are inherited unchanged.
+    class GlossNaryRelation < Lutaml::Model::Serializable
+      attribute :identifier, :string
+      attribute :comprehensive_uri, :string
+      attribute :completeness, :string
+      attribute :criterion, :hash
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        predicate :comprehensive, namespace: Namespaces::GlossaristNamespace,
+                                  to: :comprehensive_uri, uri_reference: true
+        predicate :completeness, namespace: Namespaces::GlossaristNamespace,
+                                 to: :completeness, uri_reference: true
+        predicate :criterion, namespace: Namespaces::GlossaristNamespace,
+                              to: :criterion
+      end
+
+      # Content-derived subject identifier. Combines identifier,
+      # comprehensive_uri, completeness, criterion fingerprint, and
+      # each member fingerprint. Same content → same hash across
+      # instances, runs, and processes.
+      #
+      # Concrete subclasses override to specify the member attribute
+      # name and member deterministic_id callable.
+      def self.deterministic_id(_relation)
+        raise NotImplementedError,
+              "#{name}.deterministic_id must be overridden by the concrete leaf"
+      end
+
+      # Stable, ordering-insensitive fingerprint of a localized
+      # criterion hash. Two relations with the same comprehensive,
+      # completeness, and criterion produce the same fingerprint
+      # regardless of hash-iteration order.
+      def self.criterion_fingerprint(criterion)
+        return nil unless criterion.is_a?(Hash) && !criterion.empty?
+
+        criterion.sort_by { |k, _| k.to_s }
+          .map { |k, v| "#{k}=#{v}" }
+          .join(";")
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_partitive_member.rb

@@ -4,24 +4,11 @@ require "lutaml/model"
 
 module Glossarist
   module Rdf
-    # RDF view for V3::PartitiveMember. Emits a gloss:PartitiveMember
-    # subject carrying the ConceptRef target plus the ISO 704:2022
-    # orthogonal dimensions (presence, count, is_delimiting).
-    #
-    # Subject identity is content-derived so the same member in the
-    # same relation produces the same URI across runs (and across
-    # processes). Two members with identical ref + dimensions share a
-    # subject — that is intentional: it exposes model-level
-    # inconsistency if the same partitive concept is given different
-    # dimensions inside the same dataset.
-    class GlossPartitiveMember < Lutaml::Model::Serializable
-      attribute :ref_id, :string
-      attribute :ref_source, :string
-      attribute :ref_text, :string
-      attribute :presence, :string
-      attribute :count, :string
-      attribute :is_delimiting, :boolean
-
+    # RDF view for V3::PartitiveMember. Inherits attributes and
+    # deterministic_id from GlossNaryMember. The `rdf do` block
+    # re-declares the predicates because lutaml-model's `rdf` DSL
+    # replaces the parent mapping (not extends).
+    class GlossPartitiveMember < GlossNaryMember
       rdf do
         namespace Namespaces::GlossaristNamespace
 
@@ -42,16 +29,6 @@ module Glossarist
         predicate :isDelimiting, namespace: Namespaces::GlossaristNamespace,
                                  to: :is_delimiting
       end
-
-      def self.deterministic_id(member)
-        readable = [member.ref_source, member.ref_id].compact.reject(&:empty?)
-        return readable.join(":") unless readable.empty?
-
-        DeterministicSlug.from_parts(
-          member.ref_source, member.ref_id, member.ref_text,
-          member.presence, member.count, member.is_delimiting
-        )
-      end
     end
   end
 end

data/lib/glossarist/rdf/gloss_partitive_relation.rb

@@ -4,25 +4,20 @@ require "lutaml/model"
 
 module Glossarist
   module Rdf
-    # RDF view for V3::PartitiveRelation. Emits a
-    # gloss:PartitiveRelation subject with comprehensive, completeness,
-    # criterion properties, plus hasPartitive (concept URIs, for graph
-    # traversal) and hasPartitiveMember (typed subjects carrying the
-    # ISO 704:2022 per-member dimensions).
-    class GlossPartitiveRelation < Lutaml::Model::Serializable
-      attribute :identifier, :string
-      attribute :comprehensive_uri, :string
+    # RDF view for V3::PartitiveHyperedge. Inherits structure and
+    # helpers from GlossNaryRelation. The `rdf do` block re-declares
+    # the predicates because lutaml-model's `rdf` DSL replaces the
+    # parent mapping (not extends).
+    class GlossPartitiveRelation < GlossNaryRelation
       attribute :partitive_member_ids, :string, collection: true
       attribute :partitive_members, GlossPartitiveMember, collection: true
-      attribute :completeness, :string
-      attribute :criterion, :hash
 
       rdf do
         namespace Namespaces::GlossaristNamespace
 
         subject { |r| "partitiveRelation/#{GlossPartitiveRelation.deterministic_id(r)}" }
 
-        types "gloss:PartitiveRelation"
+        types "gloss:PartitiveHyperedge"
 
         predicate :comprehensive, namespace: Namespaces::GlossaristNamespace,
                                   to: :comprehensive_uri, uri_reference: true
@@ -44,14 +39,6 @@ module Glossarist
         end
         DeterministicSlug.from_parts(*parts)
       end
-
-      def self.criterion_fingerprint(criterion)
-        return nil unless criterion.is_a?(Hash) && !criterion.empty?
-
-        criterion.sort_by { |k, _| k.to_s }
-          .map { |k, v| "#{k}=#{v}" }
-          .join(";")
-      end
     end
   end
 end

data/lib/glossarist/rdf.rb

@@ -45,6 +45,10 @@ module Glossarist
     autoload :GlossFormula,           "#{__dir__}/rdf/gloss_formula"
     autoload :GlossPartitiveRelation, "#{__dir__}/rdf/gloss_partitive_relation"
     autoload :GlossPartitiveMember,   "#{__dir__}/rdf/gloss_partitive_member"
+    autoload :GlossGenericRelation,   "#{__dir__}/rdf/gloss_generic_relation"
+    autoload :GlossGenericMember,     "#{__dir__}/rdf/gloss_generic_member"
+    autoload :GlossNaryRelation,      "#{__dir__}/rdf/gloss_nary_relation"
+    autoload :GlossNaryMember,        "#{__dir__}/rdf/gloss_nary_member"
     autoload :V3,                     "#{__dir__}/rdf/v3"
   end
 end

data/lib/glossarist/tasks/shacl.rake

@@ -3,7 +3,10 @@
 require "rdf/turtle"
 require "shacl"
 require "pathname"
-require "glossarist/validation/shacl_validator"
+# Entry-point require triggers the autoload chain
+# (Glossarist → Validation → ShaclValidator). Internal-path requires
+# are forbidden by the autoload rule.
+require "glossarist"
 
 namespace :glossarist do
   desc "Validate all .ttl outputs against concept-model SHACL shapes. " \