expressir 2.4.26 → 2.4.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51179b5984b4c7c9f6f02e1b306c31e8f9b1b7ec420f7923b4b96957601244a1
-  data.tar.gz: 15b0e981214636104b47fa472f69736612f192907783adf894160b1517288f03
+  metadata.gz: 45dd9d5d13614ca549340d534defb9a674a5fca35a9f3b16f5ef345b73e263eb
+  data.tar.gz: f5a14e8e4cb49ebebe7823d9015de7296459735b3f8ea06edc3494e072b0877f
 SHA512:
-  metadata.gz: 44a3da19b7db2986d8b841641366254f1b365e09803d881a753ab946562dddf75513a8107dff8201bc457848535726d47ebc85f32faa37a70841f048803f5c5d
-  data.tar.gz: 8da0ff1bdc5742383defcae54413bb201faed4b26a8a9c7c50c5aa194a02b1d5fb6ae8e8015aa51a4090bcb4347ff6978aad4aacd1951f86d358357d5e2b4398
+  metadata.gz: d46d905d2f0ca978c614cba3574a398fa38809f38296930115905b9e97cf1e223e8b0882c1c7431e026dc97015579f7e820f067173da4645ede0be33a00c6842
+  data.tar.gz: bc103128faa28cbaafdb27a61117431c9b17d77913b4dcc038db64638b815f19be7e90c4366ca45ef378196f360445296244cd40c435997038280d776de94dd1

data/.github/workflows/native-gems.yml

@@ -52,7 +52,12 @@ jobs:
           EXPRESSIR_CORE_FORCE: "1"
         with:
           platform: ${{ matrix.ruby-platform }}
-          ruby-versions: "3.2,3.3,3.4,4.0"
+          # Dock images provision cross rubies for 3.2-3.4 only; a 4.0
+          # leg silently falls back to the dock's host toolchain and
+          # fails linking (or worse, links against the wrong ruby).
+          # Ruby 4.0 users on these platforms get the pure-Ruby parser
+          # fallback until the images ship 4.0 cross rubies.
+          ruby-versions: "3.2,3.3,3.4"
 
       - uses: actions/upload-artifact@v4
         with:

data/TODO.refpath-v2/00-overview.md

@@ -0,0 +1,64 @@
+# 00 — RefPath v2: ELF 5006 conformance
+
+Goal: make `Expressir::Mapping::RefPath` a conforming validator for the
+EXPRESS mapping language specification (ELF 5006:2025,
+`~/src/expresslang/docs/sources/express-mapping/`), so that the WG12
+validation of annotated EXPRESS links (TRThurman PDES proposal,
+expressir 2.4.20+ capability, AP 242 ed5 DIS December 2026) finds
+expressir ready at every reference position.
+
+## Gap matrix (ELF 5006 §8 vs current RefPath)
+
+| §8 requirement | status |
+|---|---|
+| entity existence, case-insensitive | done |
+| `<=` / `=>` subtype/supertype, direct or transitive | done |
+| attribute existence for `->` / `<-` (inherited attrs) | done |
+| forward/inverse TYPE compatibility (attr type references target; SELECT membership) | v2 |
+| navigation continuity (running path context) | v2 |
+| constraint: entity in path context; attribute exists; not DERIVED/INVERSE | v2 |
+| constraint value typing (STRING/INTEGER/REAL/NUMBER/BOOLEAN/LOGICAL/ENUMERATION/SELECT table) | v2 |
+| start entity = ARM entity (relaxable for attribute mappings); end entity = MIM/aimelt | v2 |
+| `*>` / `<*` select extension semantics | v2 |
+| `!{...}` negation, `<...>` required path, `||...||` marker, `*...*` tree | v2 (tokenize + semantics) |
+| collect-all-errors | done |
+| structured output (text/JSON/YAML), per-path VALID/INVALID | v2 |
+| case-mismatch warnings (optional) | v2 optional |
+
+## Mapping-model gaps (ae-level fields in the wg12-step corpus)
+
+587 module mapping files; keys beyond the current model:
+
+- `rules` — 159 ae entries carry a rules list (a reference position in
+  the PDES proposal: "the rules list").
+- `alt_map` — 74 ae entries carry an alternative map ("an alternative
+  map" reference position).
+
+Both must be modeled with lutaml-model attributes (never hand-rolled
+parsing) and their link/reference positions validated like ae/sc.
+
+## Validation semantics (per §8 + §5/§6)
+
+- Running context: the entity a path is "at". `<=`/`=>` move to the
+  right-hand entity; `a.attr -> b` requires attr on the current entity
+  whose type references b (supertypes and SELECT options count), moves
+  to b; `b <- a.attr` same checks, moves to a; `[i]`/`[n]` keep the
+  element type as context; a bare name restates or continues the
+  context (§6 chaining).
+- Constraints `{e ... e.attr = v}`: e equals the current context entity
+  (§8: "at or before the constraint location"); attr exists on e and is
+  not DERIVED/INVERSE; v typed per the §8 table (STRING single-quoted,
+  INTEGER/REAL/NUMBER unquoted, BOOLEAN TRUE/FALSE, LOGICAL +UNKNOWN,
+  ENUMERATION item of the attribute's type, SELECT option match).
+  `!{...}` inverts the finding.
+- Start entity: compatible with the ae `entity` (relaxed for aa-level
+  paths). End entity: a MIM-declared entity (cross-check `aimelt`).
+
+## Test oracle
+
+- `spec/expressir/mapping/refpath_spec.rb` — extend with one example
+  per §8 rule (firing + clean negative).
+- Corpus: all 587 module mapping.yaml files; the suma MappingDrift
+  baseline (1541 entries) is the pre-v2 reference; v2 must not add
+  errors on paths the corpus proves valid, and must explain every new
+  error by an ELF 5006 rule.

data/lib/expressir/commands/mapping_validate.rb

@@ -21,10 +21,16 @@ module Expressir
           say "refpath #{location} [step #{issue.step}]: #{issue.message}"
         end
 
-        total = unknown.size + issues.size
+        rule_issues = Expressir::Mapping.rule_issues(document, repository)
+        rule_issues.each do |missing|
+          say "unknown rule: #{missing.text}"
+        end
+
+        total = unknown.size + issues.size + rule_issues.size
         unless total.zero?
           raise Thor::Error, "#{unknown.size} unknown link(s), " \
-                             "#{issues.size} refpath issue(s)"
+                             "#{issues.size} refpath issue(s), " \
+                             "#{rule_issues.size} unknown rule(s)"
         end
 
         say "all links and reference paths resolve"
@@ -35,10 +41,12 @@ module Expressir
       def refpath_issues(document, repository)
         Expressir::Mapping.refpaths(document).flat_map do |location, content|
           parsed = Expressir::Mapping::RefPath.parse(content)
+          start = Expressir::Mapping.entity_item(location)
           parsed.parse_errors.map do |error|
             [location, Expressir::Mapping::RefPath::Issue.new(step: nil,
                                                               message: error)]
-          end + Expressir::Mapping::RefPath.validate(parsed, repository)
+          end + Expressir::Mapping::RefPath.validate(parsed, repository,
+                                                     start: start)
             .map { |issue| [location, issue] }
         end
       end

data/lib/expressir/express/parser.rb

@@ -161,8 +161,13 @@ module Expressir
 
         repository = build_repository(all_exp_files, skip_references: skip_references)
         if set_path && !skip_references && !File.exist?(set_path) &&
-            core_set_available? && !all_exp_files.include?(nil)
-          write_compiled_set(set_path, files, all_exp_files, root_path)
+            !all_exp_files.include?(nil)
+          if core_set_available?
+            write_compiled_set(set_path, files, all_exp_files, root_path)
+          else
+            warn "expressir: compiled-set write to #{set_path} skipped: " \
+                 "the expressir-core native extension is unavailable"
+          end
         end
         if set_path && !skip_references && File.exist?(set_path)
           files = all_exp_files.compact
@@ -247,7 +252,6 @@ module Expressir
       def self.core_set_available?
         Core::NATIVE_AVAILABLE && ::Expressir::Core.const_defined?(:Set, false)
       end
-      private_class_method :core_set_available?
 
       # Concurrent core-path parse: workers compile in the background
       # while this thread hydrates, attaches remarks, and reports

data/lib/expressir/mapping/refpath.rb

@@ -4,39 +4,36 @@ module Expressir
   module Mapping
     # Formalization, parser, and validator for MIM reference paths
     # (expressir#88): the "Reference path" sections of module
-    # mapping.yaml files, written in the ISO 10303 module mapping
-    # notation. Until now the notation was prose for humans only; this
-    # makes it machine-readable and checks it against real schemas.
+    # mapping.yaml files, written in the EXPRESS mapping language
+    # (ELF 5006:2025). Until now the notation was prose for humans
+    # only; this makes it machine-readable and checks it against real
+    # schemas.
     #
-    # Grammar (corpus-verified over all module mapping.yaml refpaths):
+    # Grammar (ELF 5006 §5; corpus-verified over all module
+    # mapping.yaml refpaths):
     #   path       := step+
     #   step       := [link] node [index] [constraint]
+    #               | constraint
     #               | MARKER
-    #   link       := "->" | "<-" | "<=" | "=>" | "=" NAME
-    #                                            (relation to the previous node)
+    #   link       := "->" | "<-" | "<=" | "=>" | "*>"
+    #               | "<*" | "=" NAME (relation to the previous node)
     #   node       := NAME ["." ATTRIBUTE]
     #               | LINK                    (<<express:SCHEMA.ITEM,ITEM>>,
     #                                          #460: a link may stand
     #                                          wherever a declaration
     #                                          is referenced)
     #   index      := "[" ("i" | DIGITS) "]"
+    #   constraint := ["!"] "{" NAME [NAME "."] "=" STRING "}"
     #   MARKER     := "{" | "}" | "[" | "]" | "(" | ")" | ":" | "|" | "!"
-    #               | "," | "/" | "*"           (grouping/annotation; no
-    #                                            node semantics; never
-    #                                            breaks a pending link)
-    #   constraint := "=" STRING
+    #               | "," | "/" | "*" | "<" | ">" (grouping/annotation;
+    #                                               never breaks a
+    #                                               pending link)
     #
-    # Operator semantics per the module conventions:
-    #   ->   the attribute named before -> references the entity or
-    #        select type named after ->
-    #   <-   the attribute named before <- is referenced by the type
-    #        named after <-
-    #   <=   the entity named before <= is a subtype of the entity after
-    #   =>   the entity named before => is a supertype of the entity after
-    #   =    the node before = is of the type named after (used inside
-    #        parenthesized alternatives, e.g. `(unit = named_unit)`)
-    #   [i]  the attribute named before [i] is an aggregate; any element
-    #        of that aggregate is referred to
+    # Validation (ELF 5006 §8): a running path context tracks the
+    # entity a path is "at"; each step must connect to it, attribute
+    # navigations must be type-compatible with their target, and
+    # constraints must reference an entity in the path context with an
+    # existing, constrainable attribute whose type accepts the literal.
     module RefPath
       # Wire-name mapping is declared here so a parsed path can itself
       # be serialized with lutaml-model.
@@ -46,8 +43,11 @@ module Expressir
         attribute :attribute, :string
         attribute :index, :string
         attribute :literal, :string
-        # annotated EXPRESS link form: <<express:SCHEMA.ITEM,ITEM>>
         attribute :link, :string
+        attribute :negated, :boolean
+        # For constraint steps: the entity owning the constrained
+        # attribute when it differs from the constrained entity.
+        attribute :owner, :string
 
         key_value do
           map "operator", to: :operator
@@ -56,6 +56,8 @@ module Expressir
           map "index", to: :index
           map "literal", to: :literal
           map "link", to: :link
+          map "negated", to: :negated
+          map "owner", to: :owner
         end
       end
 
@@ -69,13 +71,43 @@ module Expressir
         end
       end
 
+      # ELF 5006 §8 "Validation output": one structured verdict per
+      # path, serializable to YAML/JSON for the toolchain.
+      class ReportIssue < Lutaml::Model::Serializable
+        attribute :step, :integer
+        attribute :message, :string
+
+        key_value do
+          map "step", to: :step
+          map "message", to: :message
+        end
+      end
+
+      class Report < Lutaml::Model::Serializable
+        attribute :status, :string
+        attribute :start, :string
+        attribute :ending, :string
+        attribute :steps, :integer
+        attribute :entities, :string, collection: true
+        attribute :issues, ReportIssue, collection: true
+
+        key_value do
+          map "status", to: :status
+          map "start", to: :start
+          map "ending", to: :ending
+          map "steps", to: :steps
+          map "entities", to: :entities
+          map "issues", to: :issues
+        end
+      end
+
       EXPRESS_LINK_PATH = /\A<<express:([^,>]+)(?:,[^>]+)?>>\z/
       private_constant :EXPRESS_LINK_PATH
 
-      TOKEN = /<<express:[^,>]+(?:,[^>]+)?>>|->|<-|<=|=>|[{}\[\]()=:|!,*\/]|'(?:''|[^'])*'|\w+(?:\.\w+)?/
+      TOKEN = /<<express:[^,>]+(?:,[^>]+)?>>|->|<-|<=|=>|\*>|<\*|!?\{|[{}\[\]()=:|!,*\/<>]|'(?:''|[^'])*'|\w+(?:\.\w+)?/
       MARKERS = ["{", "}", "[", "]", "(", ")", ":", "|", "!", ",", "/",
-                 "*", "MAPPING_OF"].freeze
-      LINKS = ["->", "<-", "<=", "=>"].freeze
+                 "*", "<", ">", "MAPPING_OF", "!{"].freeze
+      LINKS = ["->", "<-", "<=", "=>", "*>", "<*"].freeze
       DECLARATION_COLLECTIONS = %i[types entities].freeze
       private_constant :TOKEN, :MARKERS, :LINKS, :DECLARATION_COLLECTIONS
 
@@ -83,6 +115,23 @@ module Expressir
 
       module_function
 
+      # @return [Report] the structured VALID/INVALID verdict for
+      #   +content+ (ELF 5006 §8 Validation output), carrying the
+      #   traversed entities and every collected issue.
+      def report(content, repository, start: nil)
+        path = parse(content)
+        issues = validate(path, repository, start: start)
+        entities = path.steps.filter_map(&:name).uniq
+        Report.new(
+          status: (issues.empty? && path.parse_errors.empty? ? "VALID" : "INVALID"),
+          start: start || entities.first,
+          ending: entities.last,
+          steps: path.steps.size,
+          entities: entities,
+          issues: issues.map { |i| ReportIssue.new(step: i.step, message: i.message) },
+        )
+      end
+
       # @param content [String] the mapping.yaml refpath content block
       # @return [Path]
       def parse(content)
@@ -91,10 +140,26 @@ module Expressir
         errors = []
         pending_link = nil
         pending_type_assign = false
+        false
         i = 0
         while i < tokens.length
           token = tokens[i]
           case token
+          when "!{"
+            true
+            step, consumed = parse_constraint(tokens[i..], negated: true)
+            steps << step
+            i += consumed
+            pending_link = nil
+            pending_type_assign = false
+            next
+          when "{"
+            step, consumed = parse_constraint(tokens[i..], negated: false)
+            steps << step
+            i += consumed
+            pending_link = nil
+            pending_type_assign = false
+            next
           when *LINKS
             pending_link = token
           when "="
@@ -136,6 +201,38 @@ module Expressir
         Path.new(steps: steps, parse_errors: errors)
       end
 
+      # A constraint block from +tokens+ (which start at "{" or "!{"):
+      # "{entity" or "{entity attr = literal}". Returns
+      # [Step, tokens_consumed].
+      def parse_constraint(tokens, negated:)
+        inner = []
+        consumed = 1
+        tokens[1..].each do |token|
+          consumed += 1
+          break if token == "}"
+
+          inner << token
+        end
+        eq = inner.index("=")
+        value = eq && inner[eq + 1]
+        literal = value || inner.find { |t| t.start_with?("'") }
+        names = inner.select { |t| t.match?(/\A\w+(\.\w+)?\z/) && !t.start_with?("'") }
+        qualified = names.find { |t| t.include?(".") }
+        entity = if qualified && names.size == 1
+                   # {entity.attr = value} with the entity named only inside
+                   # the qualified reference
+                   qualified.split(".", 2)[0]
+                 else
+                   names.find { |t| !t.include?(".") }
+                 end
+        owner, attribute = qualified ? qualified.split(".", 2) : [nil, nil]
+        owner = nil if entity && owner&.safe_downcase == entity.safe_downcase
+        step = Step.new(operator: "{", name: entity,
+                        attribute: attribute, literal: literal,
+                        negated: negated, owner: owner)
+        [step, consumed]
+      end
+
       def index_token?(token)
         token == "i" || token&.match?(/\A\d+\z/)
       end
@@ -155,28 +252,473 @@ module Expressir
       end
 
       # Validate a parsed path against a repository. Issues reference
-      # the step index they attach to.
+      # the step index they attach to. +start+ names the ARM entity the
+      # path is expected to begin at (the ae entity); when given and
+      # the path's first entity differs, a warning-level issue is
+      # recorded (ELF 5006 §8: the rule "may be relaxed for attribute
+      # mappings").
       # @return [Array<Issue>]
-      def validate(path, repository)
+      def validate(path, repository, start: nil)
         by_name = name_index(repository)
         issues = []
-        prev = nil
+        ctx = nil
+        seen = {}
         last_qualified = nil
         path.steps.each_with_index do |step, pos|
           # markers never break the running link, mirroring parse
-          next if MARKERS.include?(step.operator)
+          next if marker_step?(step)
 
           if step.link
             issues.concat(check_link_step(step, pos, repository))
+            prev = preceding_name(steps_before(path, pos))
+            if step.name
+              check_exists(issues, pos, step.name, by_name)
+              ctx = step.name&.safe_downcase
+            elsif prev
+              ctx = prev&.safe_downcase
+            end
+            last_qualified = nil
+            next
+          end
+
+          case step.operator
+          when "(", ")"
+            # alternative sections: each starts a fresh path context
+            ctx = nil
+            last_qualified = nil
+          when "{"
+            issues.concat(check_constraint(step, pos, ctx, seen, by_name))
+          when "<=", "=>"
+            issues.concat(relation_issues(step, pos, ctx, by_name))
+            ctx = step.name&.safe_downcase
+          when "->"
+            issues.concat(forward_issues(step, pos, ctx, last_qualified, by_name))
+            ctx = step.name&.safe_downcase
+            last_qualified = nil
+          when "<-"
+            issues.concat(inverse_issues(step, pos, ctx, by_name))
+            ctx = step.name&.safe_downcase
+            last_qualified = step.attribute ? step : nil
+          when "*>", "<*"
+            issues.concat(select_extension_issues(step, pos, ctx, by_name))
+            ctx = step.name&.safe_downcase
           else
-            issues.concat(check_step(step, pos, prev, last_qualified, by_name))
+            issues.concat(check_step(step, pos, ctx, last_qualified, by_name))
+            if step.name
+              seen[step.name.safe_downcase] = true
+              last_qualified = step.attribute ? step : nil
+              ctx = step.name.safe_downcase unless ctx == step.name.safe_downcase && step.attribute
+            end
+          end
+        end
+        if start && path.steps.any?(&:name)
+          first = path.steps.find { |s| s.name && !s.link }
+          if first && first.name&.safe_downcase != start.safe_downcase
+            issues << Issue.new(step: 0,
+                                message: "path starts at '#{first.name}' but " \
+                                         "the mapped entity is '#{start}'")
+          end
+        end
+        issues
+      end
+
+      def marker_step?(step)
+        step.name.nil? && step.attribute.nil? && step.link.nil? &&
+          step.operator != "{" && step.operator != "(" && step.operator != ")"
+      end
+
+      def steps_before(path, pos)
+        path.steps[0...pos].reverse_each
+      end
+
+      def preceding_name(steps)
+        steps.find { |s| s.name && !s.link }&.name
+      end
+
+      def check_exists(issues, pos, name, by_name)
+        return if name.nil? || by_name.key?(name.safe_downcase)
+
+        issues << Issue.new(step: pos,
+                            message: "unknown type '#{name}'")
+      end
+
+      # ELF 5006 §8 constraint validation: the constrained entity must
+      # exist and appear in the path context; the constrained attribute
+      # must exist on it and be constrainable (not DERIVED/INVERSE);
+      # the literal must type-check against the attribute's type.
+      def check_constraint(step, pos, ctx, seen, by_name)
+        issues = []
+        entity = step.name
+        check_exists(issues, pos, entity, by_name)
+        return issues if entity.nil?
+
+        key = entity.safe_downcase
+        in_context = (ctx && ctx == key) || seen[key]
+        unless in_context
+          issues << Issue.new(step: pos,
+                              message: "constraint entity '#{entity}' is not " \
+                                       "in the path context")
+        end
+
+        owner_key = (step.owner || entity).safe_downcase
+        decl = by_name[owner_key]&.last
+        return issues unless decl.is_a?(Model::Declarations::Entity)
+
+        if step.attribute
+          attribute = find_attribute(decl, step.attribute, by_name)
+          unless attribute
+            issues << Issue.new(step: pos,
+                                message: "entity '#{entity}' has no attribute " \
+                                         "'#{step.attribute}'")
+            return issues
+          end
+
+          if attribute.respond_to?(:kind) &&
+              [Model::Declarations::Attribute::DERIVED, Model::Declarations::Attribute::INVERSE].include?(attribute.kind)
+            issues << Issue.new(step: pos,
+                                message: "attribute '#{entity}." \
+                                         "#{step.attribute}' is " \
+                                         "#{attribute.kind} and cannot be " \
+                                         "constrained")
           end
-          prev = step if step.name || step.link
-          last_qualified = step if step.name && step.attribute
+
+          type = attribute.respond_to?(:type) ? attribute.type : nil
+          issue = value_type_issue(type, step.literal, entity,
+                                   step.attribute, by_name)
+          issues << Issue.new(step: pos, message: issue) if issue
+        elsif step.literal
+          issues << Issue.new(step: pos,
+                              message: "constraint literal '#{step.literal}' " \
+                                       "has no attribute")
+        end
+        issues
+      end
+
+      # ELF 5006 §8 value-type compatibility table.
+      def value_type_issue(type, literal, entity, attribute, by_name)
+        return nil if literal.nil?
+
+        kind = value_kind(literal)
+        resolved = resolve_type_name(type, by_name)
+        case resolved
+        when :string
+          return nil if kind == :string
+
+          "value #{literal} is not a single-quoted string " \
+            "(#{entity}.#{attribute} is a STRING)"
+        when :integer
+          return nil if kind == :integer
+
+          "value #{literal} is not an unquoted integer " \
+            "(#{entity}.#{attribute} is an INTEGER)"
+        when :real, :number
+          return nil if %i[integer real].include?(kind)
+
+          "value #{literal} is not an unquoted number " \
+            "(#{entity}.#{attribute} is a #{resolved.to_s.upcase})"
+        when :boolean
+          return nil if kind == :boolean
+
+          "value #{literal} is not TRUE or FALSE " \
+            "(#{entity}.#{attribute} is a BOOLEAN)"
+        when :logical
+          return nil if %i[boolean logical].include?(kind)
+
+          "value #{literal} is not TRUE, FALSE or UNKNOWN " \
+            "(#{entity}.#{attribute} is a LOGICAL)"
+        when :enumeration
+          return nil if kind == :enumeration && enumeration_item?(type, literal, by_name)
+
+          "value #{literal} is not an item of the enumeration type of " \
+            "#{entity}.#{attribute}"
+        when :select
+          nil # any value shape may be legitimate against a SELECT arm
+        end
+      end
+
+      def value_kind(literal)
+        case literal
+        when /\A'/ then :string
+        when /\A(TRUE|FALSE)\z/ then :boolean
+        when /\AUNKNOWN\z/ then :logical
+        when /\A-?\d+\z/ then :integer
+        when /\A-?\d+\.\d+\z/ then :real
+        else :enumeration
+        end
+      end
+
+      # Resolve a parsed type node to a value-domain tag for the
+      # §8 table, or nil when the type cannot be determined.
+      def resolve_type_name(type, by_name)
+        case type
+        when Model::DataTypes::Boolean then :boolean
+        when Model::DataTypes::Logical then :logical
+        when Model::DataTypes::String then :string
+        when Model::DataTypes::Integer then :integer
+        when Model::DataTypes::Real then :real
+        when Model::DataTypes::Number then :number
+        when Model::DataTypes::Enumeration then :enumeration
+        when Model::DataTypes::Select then :select
+        when Model::ModelElement
+          return resolve_type_name(type.base_type, by_name) if type.respond_to?(:base_type) && type.base_type
+
+          id = if type.respond_to?(:base_path) && type.base_path
+                 type.base_path.split(".").last
+               elsif type.respond_to?(:id)
+                 type.id
+               end
+          return nil unless id
+
+          decl = by_name[id.safe_downcase]&.last
+          return nil unless decl.is_a?(Model::Declarations::Type)
+
+          resolve_type_name(decl.underlying_type, by_name)
+        end
+      end
+
+      def enumeration_item?(type, literal, by_name)
+        item = literal.delete_prefix("'").delete_suffix("'").safe_downcase
+        case type
+        when Model::DataTypes::Enumeration
+          type.items.to_a.any? { |i| i.id&.safe_downcase == item }
+        when Model::ModelElement
+          return enumeration_item?(type.base_type, literal, by_name) if type.respond_to?(:base_type) && type.base_type
+
+          id = if type.respond_to?(:base_path) && type.base_path
+                 type.base_path.split(".").last
+               elsif type.respond_to?(:id)
+                 type.id
+               end
+          decl = id && by_name[id.safe_downcase]&.last
+          decl.is_a?(Model::Declarations::Type) &&
+            enumeration_item?(decl.underlying_type, literal, by_name)
+        end
+      end
+
+      # ELF 5006 §8 navigation validation with a running context: the
+      # attribute must exist on the context entity, and its type must
+      # be able to reference the step's target entity.
+      def forward_issues(step, pos, ctx, last_qualified, by_name)
+        issues = []
+        unless ctx
+          issues << Issue.new(step: pos,
+                              message: "'->' with no preceding entity in the " \
+                                       "path context")
+          return issues
+        end
+
+        owner = by_name[ctx]&.last
+        return issues unless owner.is_a?(Model::Declarations::Entity)
+
+        attr_name = last_qualified&.attribute || step.attribute
+        if attr_name.nil?
+          issues << Issue.new(step: pos,
+                              message: "'->' requires an attribute-qualified " \
+                                       "node before it")
+          return issues
+        end
+
+        attribute = find_attribute(owner, attr_name, by_name)
+        unless attribute
+          issues << Issue.new(step: pos,
+                              message: "entity '#{owner.id}' has no attribute " \
+                                       "'#{attr_name}'")
+          return issues
+        end
+
+        issues.concat(target_compat_issues(attribute, step, pos, ctx, by_name))
+        issues
+      end
+
+      def inverse_issues(step, pos, ctx, by_name)
+        issues = []
+        entity = step.name
+        check_exists(issues, pos, entity, by_name)
+        return issues if entity.nil?
+
+        decl = by_name[entity.safe_downcase]&.last
+        return issues unless decl.is_a?(Model::Declarations::Entity)
+
+        attr_name = step.attribute
+        if attr_name.nil?
+          issues << Issue.new(step: pos,
+                              message: "'<-' requires an attribute-qualified " \
+                                       "node after it")
+          return issues
+        end
+
+        attribute = find_attribute(decl, attr_name, by_name)
+        unless attribute
+          issues << Issue.new(step: pos,
+                              message: "entity '#{entity}' has no attribute " \
+                                       "'#{attr_name}'")
+          return issues
+        end
+
+        if ctx
+          issues.concat(target_compat_issues(attribute, step, pos, ctx, by_name,
+                                             inverse: true))
         end
         issues
       end
 
+      # ELF 5006 §8: the attribute type must reference the target
+      # entity, a supertype of it, or a SELECT whose options reach it.
+      # `ctx` is the target of the navigation either way: for `->` the
+      # step names it; for `<-` the path context carries it.
+      def target_compat_issues(attribute, step, pos, ctx, by_name, inverse: false)
+        type = attribute.respond_to?(:type) ? attribute.type : nil
+        target = inverse ? ctx : step.name
+        return [] if type.nil? || target.nil?
+        return [] if references_entity?(type, target, by_name, {}.compare_by_identity)
+
+        owner = attribute.parent.respond_to?(:id) ? attribute.parent.id : nil
+        [Issue.new(step: pos,
+                   message: "attribute '#{"#{owner}." if owner}" \
+                            "#{attribute.id}' cannot reference '#{target}'")]
+      end
+
+      def references_entity?(type, target, by_name, seen)
+        return false if type.nil? || seen[type]
+
+        seen[type] = true
+        if type.is_a?(Model::References::SimpleReference)
+          id = type.respond_to?(:base_path) && type.base_path ? type.base_path.to_s.split(".").last : type.id
+          return false if id.nil?
+
+          key = id.safe_downcase
+          return true if key == target
+
+          decl = by_name[key]&.last
+          return select_reaches?(decl, target, by_name, seen) if decl.is_a?(Model::Declarations::Type)
+
+          return entity_reaches?(decl, target, by_name, seen)
+        end
+        if type.respond_to?(:base_type) && type.base_type
+          return references_entity?(type.base_type, target, by_name, seen)
+        end
+        if type.is_a?(Model::DataTypes::Select)
+          return type.items.to_a.any? do |item|
+            id = item.respond_to?(:id) ? item.id&.safe_downcase : nil
+            next false if id.nil?
+            next true if id == target
+
+            decl = by_name[id]&.last
+            decl ? entity_reaches?(decl, target, by_name, seen) : false
+          end
+        end
+
+        false
+      end
+
+      def select_reaches?(type_decl, target, by_name, seen)
+        return false unless type_decl.is_a?(Model::Declarations::Type)
+
+        underlying = type_decl.underlying_type
+        references_entity?(underlying, target, by_name, seen)
+      end
+
+      # target is a subtype of the referenced entity decl (or equal).
+      def entity_reaches?(decl, target, by_name, _seen)
+        return false unless decl.is_a?(Model::Declarations::Entity)
+
+        key = decl.id&.safe_downcase
+        return true if key == target
+
+        supertype_ids(decl, by_name).any? { |s| s&.safe_downcase == target }
+      end
+
+      def select_extension_issues(step, pos, ctx, by_name)
+        issues = []
+        check_exists(issues, pos, step.name, by_name)
+        return issues if step.name.nil? || ctx.nil?
+
+        base = by_name[ctx]&.last
+        ext = by_name[step.name.safe_downcase]&.last
+        return issues unless base.is_a?(Model::Declarations::Type) &&
+          ext.is_a?(Model::Declarations::Type)
+
+        return issues if select_extends?(ext, base, by_name, {}.compare_by_identity)
+
+        issues << Issue.new(step: pos,
+                            message: "SELECT '#{step.name}' does not extend '#{ctx}'")
+        issues
+      end
+
+      # select_b <* select_a / select_a *> select_b: select_b extends
+      # select_a when select_b's BASED ON chain reaches select_a.
+      def select_extends?(ext, base, by_name, seen)
+        return false if seen[ext]
+
+        seen[ext] = true
+        underlying = ext.underlying_type
+        return false unless underlying.is_a?(Model::DataTypes::Select)
+
+        based = underlying.based_on
+        raw = based && (based.respond_to?(:base_path) ? based.base_path : based.id)
+        based_id = raw && raw.to_s.split(".").last
+        return true if based_id&.safe_downcase == base.id&.safe_downcase
+
+        based_decl = based_id && by_name[based_id.safe_downcase]&.last
+        based_decl ? select_extends?(based_decl, base, by_name, seen) : false
+      end
+
+      def relation_issues(step, pos, ctx, by_name)
+        target = by_name[step.name&.safe_downcase]&.last
+        source = ctx && by_name[ctx]&.last
+        return [] unless source.is_a?(Model::Declarations::Entity) &&
+          target.is_a?(Model::Declarations::Entity)
+
+        if step.operator == "<="
+          return [] if supertype_ids(source, by_name)
+            .any? { |id| id&.safe_downcase == step.name&.safe_downcase }
+
+          [Issue.new(step: pos,
+                     message: "'#{ctx}' is not a subtype of '#{step.name}'")]
+        else
+          return [] if supertype_ids(target, by_name)
+            .any? { |id| id&.safe_downcase == ctx }
+
+          [Issue.new(step: pos,
+                     message: "'#{step.name}' is not a subtype of '#{ctx}'")]
+        end
+      end
+
+      def check_step(step, pos, ctx, _last_qualified, by_name)
+        found = by_name[step.name&.safe_downcase]
+        return [Issue.new(step: pos, message: "unknown type '#{step.name}'")] unless found
+
+        issues = attribute_issues(step, pos, found[1], by_name)
+        issues.concat(bare_continuity_issue(step, pos, ctx, found, by_name))
+        issues
+      end
+
+      # ELF 5006 §8 navigation continuity: a bare node naming a
+      # different entity than the context must still be related to it
+      # (either one a supertype of the other).
+      def bare_continuity_issue(step, pos, ctx, found, by_name)
+        return [] unless ctx
+        return [] if ctx == step.name&.safe_downcase
+
+        decl = found[1]
+        return [] unless decl.is_a?(Model::Declarations::Entity)
+
+        down = ->(id) { id&.safe_downcase }
+        if supertype_ids(decl, by_name).any? { |id| down.(id) == ctx }
+          return []
+        end
+
+        ctx_decl = by_name[ctx]&.last
+        if ctx_decl.is_a?(Model::Declarations::Entity) &&
+            supertype_ids(ctx_decl, by_name).any? { |id| down.(id) == decl.id&.safe_downcase }
+          return []
+        end
+
+        [Issue.new(step: pos,
+                   message: "'#{step.name}' breaks navigation continuity " \
+                            "(context is '#{ctx}')")]
+      end
+
       EXPRESS_BUILTINS = %w[NUMBER INTEGER REAL STRING BOOLEAN LOGICAL
                             BINARY].freeze
       private_constant :EXPRESS_BUILTINS
@@ -193,8 +735,7 @@ module Expressir
         index
       end
 
-      # Annotated EXPRESS link node: <<express:SCHEMA.ITEM,ITEM>>
-      # (item part optional) resolves against the repository (#460).
+      # Validate links in aa.assertion_to (#460) and ae/sc entries.
       def check_link_step(step, pos, repository)
         parts = step.link.match(EXPRESS_LINK_PATH)
         return [Issue.new(step: pos, message: "malformed link '#{step.link}'")] unless parts
@@ -215,15 +756,6 @@ module Expressir
                             "'#{item_id}' (#{step.link})")]
       end
 
-      def check_step(step, pos, prev, last_qualified, by_name)
-        found = by_name[step.name&.safe_downcase]
-        return [Issue.new(step: pos, message: "unknown type '#{step.name}'")] unless found
-
-        issues = attribute_issues(step, pos, found[1], by_name)
-        issues.concat(link_issues(step, pos, prev, last_qualified, by_name))
-        issues
-      end
-
       def attribute_issues(step, pos, decl, by_name)
         return [] unless step.attribute
 
@@ -279,81 +811,9 @@ module Expressir
                             "aggregate but carries [#{step.index}]")]
       end
 
-      def link_issues(step, pos, prev, last_qualified, by_name)
-        return [] unless LINKS.include?(step.operator)
-        unless prev && step.name
-          return [Issue.new(step: pos,
-                            message: "#{step.operator} with no preceding node")]
-        end
-
-        case step.operator
-        when "->", "<-"
-          attribute_link_issues(step, pos, prev, last_qualified)
-        when "<=" then subtype_link_issues(step, pos, prev, by_name)
-        when "=>" then supertype_link_issues(step, pos, prev, by_name)
-        end
-      end
-
-      # `->`: the attribute-qualified node precedes the operator;
-      # `<-`: it follows (the entity before <- is referenced BY the
-      # attribute after it). An aggregate dereference `[i]` keeps the
-      # running attribute owner qualified for the next link
-      # (`attr -> list_type[i] -> element_type`).
-      def attribute_link_issues(step, pos, prev, last_qualified)
-        if step.operator == "->"
-          qualified = if prev&.attribute
-                        prev
-                      else
-                        (prev&.index ? last_qualified : nil)
-                      end
-          unless qualified&.attribute
-            return [Issue.new(step: pos,
-                              message: "'->' requires an attribute-qualified " \
-                                       "node before it, got '#{prev&.name}'")]
-          end
-
-          return []
-        end
-
-        return [] if step.attribute
-
-        [Issue.new(step: pos,
-                   message: "'<-' requires an attribute-qualified node " \
-                            "after it, got '#{step.name}'")]
-      end
-
-      # `a <= b`: a is a subtype of b.
-      def subtype_link_issues(step, pos, prev, by_name)
-        source = by_name[prev.name&.safe_downcase]&.last
-        target = by_name[step.name&.safe_downcase]&.last
-        return [] unless source.is_a?(Model::Declarations::Entity) &&
-          target.is_a?(Model::Declarations::Entity)
-
-        return [] if supertype_ids(source, by_name)
-          .any? { |id| id&.safe_downcase == step.name&.safe_downcase }
-
-        [Issue.new(step: pos,
-                   message: "'#{prev.name}' is not a subtype of '#{step.name}'")]
-      end
-
-      # `a => b`: a is a supertype of b.
-      def supertype_link_issues(step, pos, prev, by_name)
-        source = by_name[step.name&.safe_downcase]&.last
-        target = by_name[prev.name&.safe_downcase]&.last
-        return [] unless source.is_a?(Model::Declarations::Entity) &&
-          target.is_a?(Model::Declarations::Entity)
-
-        return [] if supertype_ids(source, by_name)
-          .any? { |id| id&.safe_downcase == prev.name&.safe_downcase }
-
-        [Issue.new(step: pos,
-                   message: "'#{prev.name}' is not a supertype of '#{step.name}'")]
-      end
-
-      # Supertype entity names of +entity+: the subtype_of references
-      # plus the leaves of the supertype expression tree, resolved
-      # through the repository-wide name index so inherited chains
-      # (including cross-schema USE FROM) walk correctly.
+      # ELF 5006 §8 subtype/supertype relations, resolved through the
+      # repository-wide index so inherited chains (including
+      # cross-schema USE FROM) walk correctly.
       def supertype_ids(entity, by_name)
         seen = {}.compare_by_identity
         queue = [entity]

data/lib/expressir/mapping.rb

@@ -41,12 +41,33 @@ module Expressir
       end
     end
 
+    # An alternative mapping for an application element (corpus
+    # `alt_map:` entries): the same ARM concept mapped through a
+    # different MIM route, with its own reference path and rules.
+    class AltMap < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :description, ReferencePath
+      attribute :aimelt, :string
+      attribute :refpath, ReferencePath
+      attribute :rules, ReferencePath
+
+      key_value do
+        map "id", to: :id
+        map "description", to: :description
+        map "aimelt", to: :aimelt
+        map "refpath", to: :refpath
+        map "rules", to: :rules
+      end
+    end
+
     class ApplicationElement < Lutaml::Model::Serializable
       attribute :entity, :string
       attribute :aimelt, :string
       attribute :extensible, :string
       attribute :original_module, :string
       attribute :refpath, ReferencePath
+      attribute :rules, ReferencePath
+      attribute :alt_map, AltMap, collection: true
       attribute :aa, AttributeMapping, collection: true
 
       key_value do
@@ -55,6 +76,8 @@ module Expressir
         map "extensible", to: :extensible
         map "original_module", to: :original_module
         map "refpath", to: :refpath
+        map "rules", to: :rules
+        map "alt_map", to: :alt_map
         map "aa", to: :aa
       end
     end
@@ -138,6 +161,9 @@ module Expressir
         [element.entity, element.aimelt] +
           element.aa.to_a.flat_map do |aa|
             [aa.attribute, aa.aimelt, aa.assertion_to]
+          end +
+          element.alt_map.to_a.flat_map do |alt|
+            [alt.aimelt, alt.description&.content]
           end
       end.compact + subtype_constraint_values(document)
     end
@@ -162,8 +188,66 @@ module Expressir
 
           entries << ["#{element.entity}.#{aa.attribute}", aa.refpath.content]
         end
+        element.alt_map.to_a.each do |alt|
+          next unless alt.refpath&.content
+
+          label = alt.id ? "#{element.entity}[#{alt.id}]" : element.entity.to_s
+          entries << [label, alt.refpath.content]
+        end
         entries
       end
     end
+
+    # Every `rules:` value in the document as [mapped entity, rule
+    # name, location label] triples — the rules-list reference
+    # position. The mapped entity is the ae entity's declared name
+    # (the item of its annotated link).
+    def rules_positions(document)
+      document.ae.to_a.flat_map do |element|
+        entity = entity_item(element.entity)
+        positions = []
+        if element.rules&.content
+          positions << [entity, element.rules.content, element.entity.to_s]
+        end
+        element.alt_map.to_a.each do |alt|
+          next unless alt.rules&.content
+
+          positions << [entity, alt.rules.content,
+                        "#{element.entity}[#{alt.id}]"]
+        end
+        positions
+      end
+    end
+
+    # The declared item of an annotated link value
+    # (<<express:SCHEMA.ITEM,ITEM>> → ITEM; bare value → itself).
+    def entity_item(value)
+      match = value.to_s.match(EXPRESS_LINK)
+      match ? match[2] || match[1].split(".").last : value.to_s
+    end
+
+    # ELF 5006 §8 rules-list validation: each named rule must be a
+    # global RULE in the repository whose FOR list includes the mapped
+    # entity (rule declarations are schema-level).
+    def rule_issues(document, repository)
+      rules_by_name = repository.schemas.flat_map(&:rules)
+        .select { |r| r.respond_to?(:id) && r.id }
+        .to_h { |r| [r.id.safe_downcase, r] }
+      rules_positions(document).filter_map do |entity, rule, _label|
+        decl = rules_by_name[rule.safe_downcase]
+        next if decl.nil? == false && entity.nil?
+        next if decl && for_list_includes?(decl, entity)
+
+        UnknownLink.new(text: "#{entity}.#{rule}", schema: entity,
+                        item: rule)
+      end
+    end
+
+    def for_list_includes?(rule_decl, entity)
+      Array(rule_decl.applies_to).any? do |ref|
+        id = ref.respond_to?(:id) ? ref.id : ref.to_s
+        id&.safe_downcase == entity.safe_downcase
+      end
+    end
   end
 end

data/lib/expressir/version.rb

@@ -3,6 +3,6 @@ module Expressir
   # autoload it (Ruby autoload only works for module/class constants, not
   # for string constants like `Expressir::VERSION`).
   module Version
-    VERSION = "2.4.26".freeze
+    VERSION = "2.4.28".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.4.26
+  version: 2.4.28
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-28 00:00:00.000000000 Z
+date: 2026-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -338,6 +338,7 @@ files:
 - TODO.parity-ee/18-mim-mapping.md
 - TODO.parity-ee/19-architecture.md
 - TODO.parity-ee/parity-matrix.md
+- TODO.refpath-v2/00-overview.md
 - TODO.suma-improvements/00-overview.md
 - TODO.suma-improvements/01-prebuilt-platform-gems.md
 - TODO.suma-improvements/02-suma-e2e.md