pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/ieee/compaction.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    # Serialization compaction for IEEE hashes — a recursive transform hooked
+    # into Ieee::Identifier#to_hash (collapse) and .from_hash (expand). Two
+    # compactions, both provably lossless and nested-safe (they descend into a
+    # Corrigendum `base` too):
+    #
+    # 1. **typed_stage -> `stage` scalar.** The multi-field `typed_stage` object
+    #    becomes a single `stage` key holding its canonical abbreviation,
+    #    rebuilt from the TYPED_STAGES registry. The abbreviation keys the
+    #    registry uniquely, and the collapse fires only when the registry's
+    #    reconstruction is byte-identical to the serialized sub-hash — an
+    #    unrecognised / non-matching stage is left as the full object (fails
+    #    closed).
+    #
+    # 2. **`draft` slash strip.** `Components::Draft#to_s` renders `"/D3"`; the
+    #    leading `/` is boilerplate, so the serialized form is `"D3"`. No expand
+    #    step is needed — `Draft.parse` already accepts the slashless form and
+    #    reproduces `"/D3"` (verified across the whole corpus), so from_hash and
+    #    rendering are unchanged.
+    #
+    # A recursive hash transform (rather than lutaml attributes) is deliberate:
+    # `stage` collides with the inherited `Components::Stage` attribute name (a
+    # redefinition would reintroduce the multi-flavor nondeterminism we hit with
+    # `number`), and only a whole-hash walk reaches a nested Corrigendum `base`,
+    # which a per-object `to_hash` override cannot (the nested-serialization
+    # wall). The runtime `typed_stage`/`draft_obj` objects are untouched.
+    module Compaction
+      module_function
+
+      # abbr => canonical serialized typed_stage sub-hash, mirroring what the
+      # parent serializer + canonicalizer emit (nils dropped, and a default
+      # `project_status: false` dropped). Memoized.
+      def sub_hash_for(abbr)
+        (@sub_hash_for ||= build_sub_hash_map)[abbr]
+      end
+
+      def build_sub_hash_map
+        TypedStages::TYPED_STAGES.to_h { |ts| [ts.abbr.first, entry_sub_hash(ts)] }
+      end
+
+      # NB: this must list every Components::TypedStage attribute. If a field is
+      # added there but not here, the collapse guard fails closed — affected
+      # stages stay full objects (still lossless) but stop compacting; extend
+      # this list to keep them compact.
+      def entry_sub_hash(typed_stage)
+        {
+          "abbr" => typed_stage.abbr,
+          "stage_code" => typed_stage.stage_code,
+          "type_code" => typed_stage.type_code,
+          "iso_stage_equivalent" => typed_stage.iso_stage_equivalent,
+          "ieee_draft_equivalent" => typed_stage.ieee_draft_equivalent,
+          "approval_status" => typed_stage.approval_status,
+          "project_status" => typed_stage.project_status || nil,
+        }.compact
+      end
+
+      # Recursively compact every hash in the tree: collapse a reproducible
+      # `typed_stage` to a `stage` scalar and strip the leading `/` off `draft`.
+      def collapse(node)
+        collapse_hash(node) if node.is_a?(::Hash)
+        node.each { |v| collapse(v) } if node.is_a?(::Array)
+        node
+      end
+
+      def collapse_hash(node)
+        collapse_stage(node)
+        draft = node["draft"]
+        node["draft"] = draft.delete_prefix("/") if draft.is_a?(::String)
+        node.each_value { |v| collapse(v) }
+      end
+
+      # Collapse only when the registry rebuilds the exact same sub-hash, so no
+      # information is ever lost.
+      def collapse_stage(node)
+        ts = node["typed_stage"]
+        abbr = ts["abbr"]&.first if ts.is_a?(::Hash)
+        return unless abbr && sub_hash_for(abbr) == ts
+
+        node.delete("typed_stage")
+        node["stage"] = abbr
+      end
+
+      # Inverse of {collapse} for `stage`: replace a recognised `stage` scalar
+      # with its registry typed_stage sub-hash so lutaml rebuilds the component
+      # (nested bases included). `draft` needs no expansion — Draft.parse
+      # accepts the slashless form. An unrecognised value is left alone.
+      def expand(node)
+        expand_hash(node) if node.is_a?(::Hash)
+        node.each { |v| expand(v) } if node.is_a?(::Array)
+        node
+      end
+
+      def expand_hash(node)
+        key = stage_key(node)
+        sub = sub_hash_for(node[key].to_s) if key
+        if sub
+          node.delete(key)
+          node["typed_stage"] = deep_dup(sub)
+        end
+        node.each_value { |v| expand(v) }
+      end
+
+      def stage_key(node)
+        return :stage if node.key?(:stage)
+
+        "stage" if node.key?("stage")
+      end
+
+      def deep_dup(node)
+        case node
+        when ::Hash then node.transform_values { |v| deep_dup(v) }
+        when ::Array then node.map { |v| deep_dup(v) }
+        else node
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/components/draft.rb

@@ -42,19 +42,59 @@ day: nil)
           self.day = day
         end
 
-        # Parse a draft string like "D5", "D3.4", or "5" into a Draft object.
+        # Month names as an alternation, longest-first so "September" wins over
+        # "Sep"; each may carry a trailing period ("Sept."). Used to split a
+        # rendered draft's trailing date back out.
+        MONTH_ALTERNATION =
+          MONTH_NAMES.keys.sort_by { |m| -m.length }
+            .map { |m| "#{Regexp.escape(m)}\\.?" }.join("|").freeze
+        private_constant :MONTH_ALTERNATION
+
+        DATE_SUFFIX =
+          /(?:(, | )(#{MONTH_ALTERNATION})(?: (\d{1,2}))?(?:, | )| )((?:19|20)\d{2}[a-z]{0,2})\z/
+        private_constant :DATE_SUFFIX
+
+        # Parse a rendered draft such as "/D3", "/D3.4", "/D7 Jul 2019", or a
+        # bare "D5"/"5" back into a Draft. This is the exact inverse of #to_s:
+        # `Draft.parse(d.to_s).to_s == d.to_s` must hold, because the identifier
+        # stores the draft as its rendered string and rebuilds the object with
+        # this method after `from_hash` (a mismatch breaks `to_hash` round-trip).
         # @param value [String, Draft] the value to coerce
         # @return [Draft]
         def self.parse(value)
           return value if value.is_a?(Draft)
 
-          str = value.to_s
-          if str =~ /^D(\d+)(?:\.(\d+))?/
-            new(version: $1, revision: $2)
-          else
-            new(version: str)
-          end
+          body = strip_prefix(value.to_s)
+          version, month, day, year, comma = split_date(body)
+          draft = new(version: version, month: month, day: day, year: year)
+          draft.comma_before_month = comma
+          draft
+        end
+
+        # Remove the leading "/D" (or a bare leading "D"/"/") that #to_s emits,
+        # leaving the version and any trailing date.
+        def self.strip_prefix(str)
+          return str[2..] if str.start_with?("/D")
+          return str[1..] if str.start_with?("/")
+          return str[1..] if str.start_with?("D") && str.length > 1
+
+          str
+        end
+        private_class_method :strip_prefix
+
+        # Split a trailing rendered date off the version, so the version stays
+        # clean (the SI/PSI renderer reads `draft_obj.version` directly). Returns
+        # [version, month, day, year, comma_before_month].
+        def self.split_date(body)
+          m = body.match(DATE_SUFFIX)
+          return [body, nil, nil, nil, false] unless m
+
+          version = body[0...m.begin(0)]
+          # The leading group is nil for the month-less " YEAR" form.
+          comma = m[1] == ", "
+          [version, m[2], m[3], m[4], comma]
         end
+        private_class_method :split_date
 
         # Convert month name to numeric value
         def convert_month(month_name)

data/lib/pubid/ieee/identifier.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
 # Pubid::Ieee::Identifier is the IEEE base class (a real Pubid::Identifier
-# subclass); IEEE builds its identifiers as instances of it directly. Its body,
-# `.parse`, and the Identifiers::Base back-compat alias live in
+# subclass); IEEE builds its identifiers as instances of it directly. Its body and `.parse` live in
 # identifiers/base.rb. This file just ensures it is loaded.
-require_relative "identifiers/base"

data/lib/pubid/ieee/identifiers/adopted_standard.rb

@@ -7,17 +7,74 @@ module Pubid
       # IEEE's adoption of another organization's standard
       # Example: "IEEE Standard No 18-1968 (ANSI C55.1-1968)"
       # This means IEEE adopted ANSI's standard C55.1-1968 as their Std No 18-1968
-      class AdoptedStandard < Base
-        # IEEE's identifier for this adopted standard
-        attribute :ieee_identifier, Base, polymorphic: true
+      class AdoptedStandard < Identifier
+        # IEEE's identifier for this adopted standard.
+        #
+        # Typed as the cross-flavor base `::Pubid::Identifier` (not the
+        # IEEE-only `Identifier`) so serialization never rejects a cross-flavor
+        # value. lutaml enforces the declared attribute type; `polymorphic:
+        # true` permits only *subclasses* of it, and a `Pubid::Ansi::…` /
+        # `Pubid::Iec::…` object is not a subclass of `Pubid::Ieee::Identifier`.
+        # The cross-flavor child carries its own `_type`, so `from_hash` routes
+        # it back via `TypeResolver`.
+        attribute :ieee_identifier, ::Pubid::Identifier, polymorphic: true
 
-        # Original identifiers from ANSI/ISO/IEC/etc (array for multi-part adoptions)
-        attribute :adopted_identifiers, Base, polymorphic: true,
+        # Original identifiers from ANSI/ASME/ISO/IEC/etc (array for multi-part
+        # adoptions). Cross-flavor by design: an `IEEE Std <n> (ANSI <m>)`
+        # adoption stores a `Pubid::Ansi::…` object here. See `ieee_identifier`
+        # above for why this must be `::Pubid::Identifier`, not IEEE-only.
+        attribute :adopted_identifiers, ::Pubid::Identifier, polymorphic: true,
                                               collection: true
 
         def publisher
           ieee_identifier&.publisher || "IEEE"
         end
+
+        # An adoption names one document by two designations and carries no
+        # number of its own, so `root.number` — the key relaton-index sorts and
+        # bsearches on — was "". Walk to the IEEE designation, which is the one
+        # IEEE files the document under, and which is also the source of truth
+        # for `publisher` above.
+        def root
+          ieee_identifier ? ieee_identifier.root : self
+        end
+
+        # The document number must reach the URN and the MR slug too, not only
+        # `#root` — the project rule that an identity-bearing marker reaches
+        # every identity surface. `UrnGenerator#code_component` and the base
+        # `mr_number_with_part` both read `code_obj`, which a wrapper does not
+        # have, so all 66 adoptions collapsed onto 5 URNs and 5 slugs — and
+        # `to_slug` is an output FILENAME, so that is 66 documents overwriting
+        # each other. Delegate to the IEEE designation, as `#root` does.
+        #
+        # `code_obj` is a plain attr_accessor on the base, not a lutaml
+        # attribute, so overriding it as a method is safe here.
+        def code_obj
+          ieee_identifier&.code_obj
+        end
+
+        # Likewise the year: without it "AIEE No 15-1944" and "AIEE No 15-1959"
+        # — two different documents — produced the same slug "aiee.std.15".
+        # This is the `mr_year` HOOK, not a `#year` method: `year` is a lutaml
+        # attribute on the base, and a method of that name would shadow the
+        # generated accessor (the CLAUDE.md landmine).
+        def mr_year
+          (year || ieee_identifier&.year)&.to_s
+        end
+
+        # `publisher` is *derived* from `ieee_identifier` (the serialized source
+        # of truth), so it must not be serialized. Emitting it breaks the
+        # canonical round-trip: the derived value is default-omitted on the parse
+        # path (publisher unset), but re-emitted after from_hash materializes the
+        # attribute default (the override then returns ieee_identifier.publisher,
+        # e.g. "AIEE", not the "IEEE" default). Drop it — ieee_identifier rebuilds
+        # it. (AdoptedStandard is always a top-level wrapper, never nested, so a
+        # to_hash-level drop is sufficient — same as JointDevelopment.)
+        def to_hash(*args)
+          hash = super
+          hash.delete("publisher") if hash.is_a?(::Hash)
+          hash
+        end
       end
     end
   end

data/lib/pubid/ieee/identifiers/amendment.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Amendment identifier for IEEE standards
+      # Represents additions/changes to a published standard
+      # Example: IEEE Std 802.3-2018/Amd 4-2020
+      class Amendment < SupplementIdentifier
+        # The amendment's own ordinal (`number`) and `year` — uniform names,
+        # not `amd_number`/`amd_year`. `number` is a plain string redefining the
+        # inherited Components::Code (leaf-safe, like the standards); `year` is
+        # the inherited base :string. `root.number` still returns the *base*
+        # document number, so the index key is unaffected. Mirrors Corrigendum.
+        attribute :number, :string
+        # `year` inherited from the base.
+
+        # TYPED_STAGES for amendment
+        # Amendment uses "Amd" abbreviation
+        TYPED_STAGES = [
+          Components::TypedStage.new(
+            abbr: ["Amd"],
+            type_code: "amendment",
+            stage_code: "published",
+          ),
+        ].freeze
+
+        # MR supplement suffix: `amd.{number}.{year}` (e.g. "/amd.4.2020").
+        # The MrString renderer recurses into `base` and appends this so the
+        # full IEEE amendment round-trips losslessly (mirrors Corrigendum).
+        def mr_supplement_suffix
+          segments = ["amd"]
+          segments << number.to_s if number
+          segments << year.to_s if year
+          segments.join(".")
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/base.rb

@@ -7,7 +7,7 @@ module Pubid
     end
 
     # Base class for all IEEE identifiers. Canonical name
-    # Pubid::Ieee::Identifier (Identifiers::Base is a back-compat alias). IEEE
+    # Pubid::Ieee::Identifier. IEEE
     # builds its identifiers as instances of this class directly.
     class Identifier < ::Pubid::Identifier
       # Generate URN for this identifier
@@ -15,12 +15,27 @@ module Pubid
       # @return [String] URN representation
 
       attribute :publisher, :string, default: -> { "IEEE" }
-      attribute :copublisher, :string, collection: true # IEC, ISO, ANSI, etc.
-      attribute :code, :string # Will store code as object in initialize
+      # IEC, ISO, ANSI, etc. `initialize_empty` makes from_hash give `[]`, the
+      # value a parsed identifier holds, so the two paths stay `==`.
+      attribute :copublisher, :string, collection: true, initialize_empty: true
+      # NB: there is deliberately NO `attribute :code`. IEEE's document code is
+      # serialized as the split index columns (number/prefix/parts/separator) on
+      # concrete leaf types via the CodeNumber mixin; `code`/`code_obj` remain a
+      # runtime-only representation (built in #initialize, read by the renderer).
+      # This holds for every IEEE type, including the historical AIEE/IRE and
+      # the NESC family: all three used to descend from
+      # Lutaml::Model::Serializable with their own `attribute :code`, and were
+      # reparented onto this base (with the CodeNumber mixin on their leaves).
       attribute :year, :string
       attribute :type, :string, default: -> { "Std" } # Std, Draft Std
       attribute :draft_status, :string                    # Unapproved, Approved, Active Unapproved
       attribute :draft, :string                           # Will store draft as object
+      # Numbered/lettered revision id, e.g. "2" for "P802.16Rev2", "i" for the
+      # relaton suffix "/R-i". IEEE's native inline "Rev<n>" and relaton's
+      # synthetic "/R-<x>" both feed this one attribute; rendered inline as
+      # "Rev<id>". `::Pubid::Identifier` has no `revision` attribute, so this is
+      # free of the number/stage multi-flavor collision landmine.
+      attribute :revision, :string
       attribute :edition, :string                         # Edition 1.0
       attribute :month, :string
       attribute :day, :string
@@ -46,8 +61,6 @@ module Pubid
       attribute :interpretation, :boolean, default: -> {
         false
       } # /INT notation
-      attribute :conf_number, :string # Conformance document number
-      attribute :conf_year, :string # Conformance document year
       attribute :ashrae_number, :string # ASHRAE Guideline number
       attribute :ashrae_year, :string # ASHRAE Guideline year
       attribute :crossref, :string # IEEE cross-reference (e.g., /C62.22.1-1996)
@@ -56,7 +69,24 @@ module Pubid
       # Store actual component objects
       attr_accessor :code_obj, :draft_obj
 
-      def initialize(**args)
+      # Accept either keyword args (`new(number: "802")`, the normal path) or a
+      # single positional attribute hash (`new({number: "802"})`). The latter is
+      # what the base `Pubid::Identifier#exclude`/matching machinery uses when it
+      # rebuilds via `self.class.new(attrs)`; without it, `exclude`/`matches?`
+      # raised ArgumentError for every IEEE identifier.
+      # Constructor parameters that are not lutaml attributes: `code` is
+      # runtime-only (kept as `code_obj`), and the draft forms are turned into
+      # component objects below.
+      def self.extra_init_keys
+        %i[code draft draft_obj]
+      end
+
+      def initialize(args = {}, **kwargs)
+        args = args.merge(kwargs) unless kwargs.empty?
+        # This override calls `super()` with no attributes and assigns through
+        # setters instead, so it bypasses the base constructor's coercion and
+        # unknown-key check. Apply them here to keep the cross-flavor contract.
+        args = self.class.normalize_init_attributes(args)
         super()
 
         # Handle typed_stage if provided
@@ -64,13 +94,15 @@ module Pubid
           self.typed_stage = args[:typed_stage]
         end
 
-        # Handle code as component object
+        # Handle code as component object. `code` is runtime-only (not a lutaml
+        # attribute) — we keep the parsed Components::Code in code_obj; every
+        # leaf serializes the split index columns (number/prefix/parts/separator)
+        # via the CodeNumber mixin instead of a `code` string. The renderer reads
+        # code_obj (base #code returns it).
         if args[:code].is_a?(String)
           self.code_obj = Components::Code.parse(args[:code])
-          self.code = args[:code]
         elsif args[:code]
           self.code_obj = args[:code]
-          self.code = args[:code].to_s
         end
 
         # Handle draft as component object
@@ -85,13 +117,26 @@ module Pubid
           self.draft = args[:draft].to_s
         end
 
-        # Set other attributes
+        # Set other attributes.
+        #
+        # A key the class accepts but does not declare as a lutaml attribute
+        # (see `extra_init_keys`) is assigned through its plain accessor.
+        # Without that, `CsaDualPublished#csa_identifier` — an `attr_accessor`
+        # by design, "stored as-is (not a Lutaml model type)" — was never
+        # assigned at all, and `renderer.rb` read nil from it:
+        # `IEEE Std 844.1-2017/CSA C22.2 No. 293.1-17` rendered back as
+        # `IEEE Std 844.1-2017/CSA`, losing the CSA designation entirely.
         attrs = self.class.attributes
+        extra = self.class.extra_init_keys
         args.each do |key, value|
           next if %i[code draft draft_obj typed_stage].include?(key)
 
           setter = :"#{key}="
-          public_send(setter, value) if attrs.key?(key)
+          if attrs.key?(key)
+            public_send(setter, value)
+          elsif extra.include?(key) && respond_to?(setter)
+            public_send(setter, value)
+          end
         end
       end
 
@@ -127,14 +172,75 @@ module Pubid
         draft_obj.numeric_month
       end
 
+      # IEEE stores its publication date as separate `year`/`month`/`day`
+      # :string attributes, not a Components::Date, so the base #exclude's
+      # `:year`->`:date` remap can't reach them (it would nil an unused `date`
+      # component and leave the strings). After the base rebuild, nil the whole
+      # date cluster when `:year`/`:date` is excluded, so a date-less reference
+      # matches every date in the bucket (relaton partial-ref matching). NB: the
+      # base #exclude also previously raised for every IEEE id (positional
+      # `self.class.new(attrs)` vs the keyword initialize) — fixed by
+      # Identifier#initialize accepting a positional hash.
+      def exclude(*args)
+        result = super
+        if args.intersect?(%i[year date])
+          %i[year month day].each do |attr|
+            result.public_send("#{attr}=", nil) if result.respond_to?("#{attr}=")
+          end
+        end
+        result
+      end
+
+      # Compact the serialized hash (recursively, so nested Corrigendum bases
+      # are compacted too) after the normal serialize + canonicalize: collapse
+      # `typed_stage` to a scalar `stage` and strip the `/` off `draft`. See
+      # Compaction for why this is a hash transform, not lutaml attributes.
+      def to_hash(*args)
+        hash = super
+        Compaction.collapse(hash) if hash.is_a?(::Hash)
+        hash
+      end
+
+      # Inverse of the to_hash compaction: expand a scalar `stage` back into the
+      # `typed_stage` sub-hash (on a deep copy, recursively) before lutaml
+      # deserializes, so nested bases rebuild their component too. `draft` needs
+      # no expansion (Draft.parse accepts the slashless form).
+      def self.from_hash(data, options = {})
+        data = Compaction.expand(Compaction.deep_dup(data)) if data.is_a?(::Hash)
+        super
+      end
+
+      # Register the identifier classes the automatic `Identifiers::*` scan
+      # cannot see, so `Pubid::Ieee::Identifier.from_hash` can route their rows
+      # back. The scan only looks at classes declared *directly* under
+      # `Identifiers`, which misses both AIEE and IRE (they live under their own
+      # `Aiee`/`Ire` namespaces) and the whole NESC family (nested one level
+      # deeper, under `Identifiers::Nesc`).
+      def self.additional_identifier_classes
+        [
+          Aiee::Identifier,
+          Ire::Identifier,
+          Identifiers::Nesc::Draft,
+          Identifiers::Nesc::Edition,
+          Identifiers::Nesc::Handbook,
+          Identifiers::Nesc::Redline,
+          Identifiers::Nesc::Standard,
+        ]
+      end
+
       # Parse IEEE identifier string.
       #
       # PreParser owns all regex/dispatch logic; this method is a thin
       # orchestrator that consumes a PreParser::Result and routes to the
       # correct builder.
       def self.parse(input)
+        unless input.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
         if input.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         result = PreParser.preprocess(input)
@@ -200,9 +306,15 @@ module Pubid
       def self.build_aiee_asa_adoption(parts)
         aiee_id = parse_single(parts[0])
         asa_id = parse_single(parts[1])
+        # `adopted_identifierS` — AdoptedStandard declares a collection. The
+        # singular spelling was not an attribute, so lutaml dropped it without
+        # a word and the ASA half of these 13 identifiers was never stored:
+        # `AIEE No 18-1934 (ASA C55 1934)` rendered back as `AIEE No 18-1934`.
+        # The unknown-key contract turned that silent loss into a raise, which
+        # is how it was found.
         Identifiers::AdoptedStandard.new(
           ieee_identifier: aiee_id,
-          adopted_identifier: asa_id,
+          adopted_identifiers: [asa_id],
         )
       end
       private_class_method :build_aiee_asa_adoption
@@ -245,12 +357,30 @@ module Pubid
         builder.original_input = input
         builder.build(parsed)
       end
-    end
 
-    module Identifiers
-      # Backward-compatible alias: IEEE's base class used to be
-      # Pubid::Ieee::Identifiers::Base. It is now Pubid::Ieee::Identifier.
-      Base = Pubid::Ieee::Identifier
+      # IEEE stores identity in `code` (prefix/number/parts) rather than the
+      # generic `number`, has its own `type` string ("Std", "Draft Std"), and
+      # carries `year` as a bare string — none of which the generic MrString
+      # renderer knows about. Override the lossless MR template directly so
+      # every IEEE identifier round-trips (issue #142). Supplements append
+      # `_{type}.{number}.{year}` recursively via mr_supplement_suffix.
+      # Lowercased to match the all-lowercase MR convention.
+      def mr_publisher
+        publisher&.to_s&.downcase
+      end
+
+      def mr_type
+        type&.downcase
+      end
+
+      def mr_number_with_part
+        code_obj&.to_s&.downcase
+      end
+
+      def mr_year
+        year&.to_s
+      end
     end
+
   end
 end

data/lib/pubid/ieee/identifiers/code_number.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      # Mixin for concrete IEEE leaf identifiers that are their own `#root` and
+      # carry a document code. It splits the code into separate, index-friendly
+      # scalar attributes and, crucially, **replaces** the serialized `code`
+      # string with them:
+      #
+      #   number    :string             bare-digit narrowing key ("802", "37")
+      #   prefix    :string             letter series designator ("C"), if any
+      #   parts     :string collection  dotted/dashed parts (["16", "1"])
+      #   separator :string             "." or "-", to render the parts back
+      #
+      # relaton's index-v2 keys its binary search on `id.root.number.to_s` and
+      # narrows a part-less reference (`IEEE 802`) to the whole bucket of parts
+      # (`802.11`, `802.16`, `802.16.1`), then matches `parts` — so `number`
+      # (part-less) and `parts` MUST be separate columns. The full `code` string
+      # is not serialized at all; `code_obj` (the runtime Components::Code the
+      # renderer/urn_generator read) is rebuilt losslessly from the four fields.
+      #
+      # Why a leaf mixin and not the base: IEEE keeps identity in `code`, so the
+      # base class's inherited generic `number` (a `Components::Code`) is nil.
+      # Redefining `attribute :number, :string` on the shared,
+      # **directly-instantiated** `Ieee::Identifier` base resolves against the
+      # parent's `Components::Code` **nondeterministically under multi-flavor
+      # load** (it passes IEEE-only but flips once every flavor is required,
+      # e.g. the full suite). Applying the split only on leaf classes that are
+      # never a superclass avoids that merge ambiguity — the same pattern
+      # CIE/IHO/IETF use. Never define a `#number` *method*: it collides with
+      # lutaml's generated accessor and corrupts attribute resolution.
+      module CodeNumber
+        def self.included(base)
+          base.attribute :number, :string
+          base.attribute :prefix, :string
+          base.attribute :parts, :string, collection: true, default: -> { [] }
+          base.attribute :separator, :string
+        end
+
+        # Accept keyword args or a single positional hash (the latter is what the
+        # base #exclude/matching rebuild passes) — see Identifier#initialize.
+        def initialize(args = {}, **kwargs)
+          super
+          sync_split_from_code_obj
+        end
+
+        # On the parse path `code_obj` is already built (base #initialize parses
+        # it from the `code:` arg); hoist its fields onto the split attributes
+        # so they serialize.
+        def sync_split_from_code_obj
+          co = code_obj
+          return unless co
+
+          self.number    = co.number
+          self.prefix    = co.prefix
+          self.parts     = co.parts
+          self.separator = co.original_separator
+        end
+
+        # After from_hash there is no `code` string and no cached object, so
+        # rebuild code_obj from the split fields. On the parse path base
+        # #initialize already set @code_obj, so the `||=` returns it unchanged.
+        def code_obj
+          @code_obj ||= rebuild_code_obj_from_split
+        end
+
+        def rebuild_code_obj_from_split
+          return nil if number.nil? || number.to_s.empty?
+
+          nonempty_parts = parts.nil? || parts.empty? ? nil : parts
+          Components::Code.new(
+            prefix: prefix,
+            number: number,
+            parts: nonempty_parts,
+            original_separator: separator,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/conformance_identifier.rb

@@ -7,8 +7,12 @@ module Pubid
       # Represents conformance test documents
       # Example: IEEE Std 802.16/Conformance01-2003
       class ConformanceIdentifier < SupplementIdentifier
-        attribute :conf_number, :string
-        attribute :conf_year, :string
+        # Uniform `number` (the conformance ordinal) + inherited `year`, not
+        # `conf_number`/`conf_year`. `number` is a plain string redefining the
+        # inherited Components::Code (leaf-safe). `root.number` still returns the
+        # base document number.
+        attribute :number, :string
+        # `year` inherited from the base.
 
         # TYPED_STAGES for conformance
         # Conformance uses "Conformance" abbreviation