pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.12

data/lib/pubid/iec/urn_parser.rb

@@ -31,16 +31,24 @@ module Pubid
       # @return [Identifier] parsed identifier
       def parse_urn(urn)
         unless urn.start_with?("urn:iec:std:")
-          raise Errors::ParseError, "Invalid IEC URN: #{urn}"
+          raise Pubid::UrnParser::Errors::ParseError, "Invalid IEC URN: #{urn}"
         end
 
         code, lang, all_parts = urn_to_code(urn)
-        raise Errors::ParseError, "Invalid IEC URN: #{urn}" unless code
+        unless code
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid IEC URN: #{urn}"
+        end
 
         id = Pubid::Iec::Identifier.parse(code)
         id.all_parts = true if all_parts && id.class.attributes.key?(:all_parts)
+        # The language slot joins codes with a hyphen ("en-fr"). Building one
+        # Language from the whole field gave a single bogus language that
+        # rendered as "(en-fr)".
         if lang && !lang.empty? && id.class.attributes.key?(:languages)
-          id.languages = [::Pubid::Components::Language.new(code: lang)]
+          id.languages = lang.split("-").map do |code|
+            ::Pubid::Components::Language.new(code: code)
+          end
         end
         id
       end
@@ -57,7 +65,8 @@ module Pubid
         all_parts = false
 
         code = head.gsub("-", "/")
-        code += " #{type}" unless type.nil? || type.empty?
+        type_code = type_slot_to_code(type)
+        code += " #{type_code}" unless type_code.empty?
         code += " #{num}"
         code += ":#{date}" unless date.nil? || date.empty?
         code += adjunct_to_code(fields[9..])
@@ -67,6 +76,8 @@ module Pubid
         # part or date, so to_s renders "IEC NNNN (all parts)").
         if deliv&.casecmp("SER")&.zero?
           all_parts = true
+        elsif (edition = edition_slot_to_code(deliv))
+          code += " #{edition}"
         elsif deliv && !deliv.empty?
           code += " #{deliv}"
         end
@@ -74,6 +85,33 @@ module Pubid
         [code, lang&.downcase, all_parts]
       end
 
+      # The type slot holds either the legacy type token ("TS"), a stage
+      # ("STAGE-10.20"), or both ("TS-STAGE-50.00"). A stage is written back as
+      # the abbreviation the grammar accepts, resolved from the registry by
+      # type code and harmonized code — so the round trip is exact in both
+      # directions. See issue #360 item 4.
+      def type_slot_to_code(type)
+        return "" if type.nil? || type.empty?
+
+        match = /\A(?:([A-Z]+)-)?STAGE-([\d.]+)\z/.match(type)
+        return type unless match
+
+        type_code = (match[1] || "IS").downcase
+        stage = Pubid::Iec.all_typed_stages.find do |s|
+          s.type_code.to_s == type_code &&
+            s.harmonized_stages&.first.to_s == match[2]
+        end
+        return "" unless stage
+
+        stage.abbr.first.to_s
+      end
+
+      # "ED-7" in the deliverable slot is an edition, not a deliverable code.
+      def edition_slot_to_code(deliv)
+        match = /\AED-(.+)\z/.match(deliv.to_s)
+        match && "ED#{match[1]}"
+      end
+
       # Port of Relaton::Iec.ajanct_to_code — recursively rebuilds amd/cor/ish
       # adjuncts from (relation, type, number, date) quartets. A "PLUS"
       # relation token (the consolidated "+" marker) yields "+"; otherwise "/".

data/lib/pubid/iec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Iec
     autoload :Components, "#{__dir__}/iec/components"

data/lib/pubid/ieee/aiee/identifier.rb

@@ -39,7 +39,7 @@ module Pubid
           Builder.new.build(parsed)
         end
 
-        def to_s(date_format: nil, trademark: false)
+        def to_s(date_format: nil, trademark: false, **opts)
           result = [publisher]
           result << type if type
           result << code.to_s if code
@@ -81,7 +81,7 @@ module Pubid
           # document number/filename downstream). It stays reachable on
           # `relationships`.
 
-          base
+          annotate_plain_render(base, **opts)
         end
       end
     end

data/lib/pubid/ieee/aiee/parser.rb

@@ -7,7 +7,7 @@ module Pubid
     module Aiee
       # Parser for AIEE (American Institute of Electrical Engineers) identifiers
       # Historical period: 1884-1963 (merged into IEEE in 1963)
-      class Parser < Parslet::Parser
+      class Parser < ::Pubid::Parser::Grammar
         # Basic building blocks
         rule(:space) { str(" ") }
         rule(:space?) { space.maybe }

data/lib/pubid/ieee/builder.rb

@@ -290,6 +290,16 @@ module Pubid
           return build_interpretation_supplement(parsed_hash)
         end
 
+        # The same document with a TRAILING DATE parses FLAT — no :base subtree,
+        # just an :interpretation marker beside the number — so the branch above
+        # skipped it and determine_identifier_class built a base-less
+        # InterpretationIdentifier that dropped the number, the part and the
+        # publisher: "IEEE Std 1003.2-1992/INT, Dec. 1994 Ed." rendered as
+        # " 1003.2-1992/INT". Mirrors build_flat_corrigendum / build_flat_amendment.
+        if parsed_hash[:interpretation] && !parsed_hash[:base]
+          return build_flat_interpretation(parsed_hash)
+        end
+
         # Handle conformance supplements (check for base + conf_number)
         if parsed_hash[:base] && parsed_hash[:conf_number]
           return build_conformance_supplement(parsed_hash)
@@ -432,6 +442,35 @@ module Pubid
         )
       end
 
+      # Build an interpretation from a FLAT parse tree — the trailing-date form,
+      # where the :interpretation marker sits beside the base's own keys instead
+      # of over a :base subtree.
+      #
+      # The trailing date is the INTERPRETATION's date (an interpretation of the
+      # 1992 edition of 1003.2, issued in Dec 1994), so it goes on the wrapper;
+      # the base keeps its own `year`. That matches the nested form, whose
+      # `int_year` also lands on the wrapper.
+      # @param parsed_hash [Hash] flat parsed data carrying :interpretation
+      # @return [Identifiers::InterpretationIdentifier]
+      def build_flat_interpretation(parsed_hash)
+        int_year = extract_value(parsed_hash[:trailing_year]) if parsed_hash[:trailing_year]
+
+        base_hash = parsed_hash.reject do |key, _|
+          %i[interpretation trailing_month trailing_year].include?(key)
+        end
+        base = build_single_identifier(base_hash)
+
+        # The trailing MONTH is deliberately dropped, matching the nested form
+        # (whose `int_year` carries no month either). It was not preserved
+        # before this change, so nothing is lost; and setting it fed the URN's
+        # month_day_component, which put "Dec." — a word with a dot — into a
+        # URN segment.
+        Identifiers::InterpretationIdentifier.new(
+          base: base,
+          year: int_year,
+        )
+      end
+
       # Build amendment supplement with recursive base parsing. Mirrors
       # {#build_corrigendum_supplement} — reconstructs the base identifier
       # string, recursively parses it, and wraps it in an Amendment.
@@ -630,7 +669,14 @@ module Pubid
         # Extract publishers from joint_publishers
         if parsed[:joint_publishers]
           joint_pub_str = extract_value(parsed[:joint_publishers])
-          attributes[:publishers] = joint_pub_str.split("/")
+          pubs = joint_pub_str.split("/")
+          attributes[:publishers] = pubs
+          # lutaml materializes attribute defaults during from_hash, so the
+          # deserialized joint carries publisher/copublisher alongside
+          # publishers; set the same shape on the parse path or the
+          # amendment-wrapped round-trip diverges on exactly those keys.
+          attributes[:publisher] = pubs.first
+          attributes[:copublisher] = pubs.drop(1)
         end
 
         # Build code with parts if present
@@ -654,6 +700,15 @@ module Pubid
         end
         attributes[:month] = extract_value(parsed[:month]) if parsed[:month]
 
+        # A text date trailing the DRAFT (pubid#216: "CD P26515/D1, March
+        # 2017") reaches the builder under :draft_month/:draft_year — the
+        # grammar captures them separately to avoid the :month/:year
+        # duplicate-subtree collision with the date clause.
+        if parsed[:draft_year]
+          attributes[:year] ||= extract_value(parsed[:draft_year])
+          attributes[:month] ||= extract_value(parsed[:draft_month])
+        end
+
         # Extract edition, from relaton's "/E-<n>" suffix (normalized to
         # "Edition <n>.0"). nil-residue hand-off item 1.
         attributes[:edition] = extract_value(parsed[:edition]) if parsed[:edition]
@@ -683,6 +738,10 @@ module Pubid
             attributes[:typed_stage] =
               Pubid::Ieee.locate_stage(stage_abbr)
           end
+        elsif parsed[:iso_published]
+          # Stage-less PUBLISHED joint form (pubid#317): ISO-led spelling,
+          # no project marker, no typed stage - renders as printed.
+          attributes[:lead_party] = "ISO"
         else
           # IEEE format - lead party is IEEE
           attributes[:lead_party] = "IEEE"
@@ -695,7 +754,19 @@ module Pubid
             Pubid::Ieee.locate_stage("P")
         end
 
-        Identifiers::JointDevelopment.new(**attributes)
+        joint = Identifiers::JointDevelopment.new(**attributes)
+
+        # Amendment tail on the joint ISO-format form (pubid#317:
+        # "8802-11:2012/Amd.1:2014(E)"): wrap the joint id, mirroring
+        # build_flat_amendment.
+        return joint unless parsed[:amd_number]
+
+        amd_year = extract_value(parsed[:amd_year]) if parsed[:amd_year]
+        Identifiers::Amendment.new(
+          base: joint,
+          number: extract_value(parsed[:amd_number]),
+          year: amd_year,
+        )
       end
 
       # Build SI/PSI identifier from parsed data
@@ -770,9 +841,14 @@ module Pubid
           # Pattern: slash >> "C" >> digits >> dot >> digits >> dot >> digits >> dash >> year_digits
           # The parsed crossref is a string - extract the number part
           # Format: C62.22.1-1996 where C is part of the crossref notation
+          # The captured slice keeps the leading slash, which is a SEPARATOR in
+          # the printed reference, not part of the number. Storing it made the
+          # secondary's code "/C62.22.1-1996", which then failed the renderer's
+          # own cross-reference test (`/^C\d+\./`) and fell through to the
+          # " and " join. Strip it.
           secondary_id = Identifiers::Standard.new(
             publisher: "IEEE",
-            number: extract_value(crossref),
+            number: extract_value(crossref).to_s.sub(%r{\A/}, ""),
           )
         elsif parsed[:secondary_joint]
           # Joint standard format: ", Std 1177-1989"
@@ -1145,6 +1221,14 @@ module Pubid
             return "P"
           elsif type_value == "Std"
             return "Std"
+          elsif type_value == "Draft Std" && parsed[:draft].nil? && parsed[:digit_draft].nil?
+            # A version-less "Draft Std" fabricates /D1 (issue #205);
+            # deriving the stage from that fabricated version renders the
+            # same P-prefixed form as an explicit "/D1" spelling, so the
+            # render reaches its fixed point in one round (pubid#318).
+            # Gated on no-draft: a dotted version ("D2.0") fails the registry
+            # lookup above and must fall through, keeping "Draft Std".
+            return "D1"
           elsif type_value.match?(/^No\.?$/)
             return type_value
           end

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

@@ -30,6 +30,38 @@ module Pubid
           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

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

@@ -15,7 +15,9 @@ module Pubid
       # @return [String] URN representation
 
       attribute :publisher, :string, default: -> { "IEEE" }
-      attribute :copublisher, :string, collection: true # IEC, ISO, ANSI, etc.
+      # 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
@@ -72,8 +74,19 @@ module Pubid
       # 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
@@ -104,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
 
@@ -208,8 +234,13 @@ module Pubid
       # 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)
@@ -275,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

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

@@ -11,6 +11,27 @@ module Pubid
         # CSA identifier is stored as-is (not a Lutaml model type)
         attr_accessor :csa_identifier
 
+        # `csa_identifier` is a real constructor parameter even though it is
+        # not a lutaml attribute, so the unknown-key contract must let it
+        # through — and the constructor must actually assign it.
+        def self.extra_init_keys
+          super + %i[csa_identifier]
+        end
+
+        # Walk to the IEEE designation for the relaton-index key: this wrapper
+        # names one document by an IEEE and a CSA number and holds neither
+        # itself, so `root.number` was "".
+        def root
+          ieee_identifier ? ieee_identifier.root : self
+        end
+
+        # Carry the number onto the URN and the MR slug as well as #root — see
+        # AdoptedStandard#code_obj. `#code` below delegates already, but the
+        # URN generator and the MR renderer both read `code_obj`.
+        def code_obj
+          ieee_identifier&.code_obj
+        end
+
         # Delegate common attributes to ieee_identifier
         def publisher
           ieee_identifier.publisher

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

@@ -18,6 +18,61 @@ module Pubid
           # Return array of both publishers
           [first_identifier&.publisher, second_identifier&.publisher].compact
         end
+
+        # `publisher` above is DERIVED from the two member identifiers (the
+        # serialized source of truth), so it must not be serialized itself.
+        # Emitting it breaks the canonical round-trip exactly as it did on
+        # Identifiers::AdoptedStandard and Identifiers::JointDevelopment: the
+        # derived value is default-omitted on the parse path (the attribute is
+        # unset), but re-emitted once from_hash materializes the attribute
+        # default, because the override then returns the members' publishers
+        # rather than the "IEEE" default. Worse here, it is an ARRAY, so the
+        # re-emitted value was the literal string `["IEEE", "IEEE"]`.
+        #
+        # This made all 25 DualPublished ids in the fixture corpus fail
+        # `from_hash(to_hash) == to_hash` — the gate relaton's index build
+        # uses, which SKIPS a document that fails it. Dropping the key is
+        # lossless: first_identifier and second_identifier rebuild it.
+        #
+        # A top-level to_hash delete is sufficient because DualPublished is
+        # only ever a top-level wrapper, never a nested `base` (where lutaml's
+        # own transform would bypass this override).
+        def to_hash(*args)
+          hash = super
+          hash.delete("publisher") if hash.is_a?(::Hash)
+          hash
+        end
+
+        # A dual-published document is one document under two designations, and
+        # this wrapper carries neither number itself — so `root.number`, the key
+        # relaton-index sorts and bsearches on, was "". Walk to the first
+        # designation, which is the one the printed reference leads with.
+        def root
+          first_identifier ? first_identifier.root : self
+        end
+
+        # Carry the number onto the URN and the MR slug as well as #root — see
+        # AdoptedStandard#code_obj for why all three surfaces need it.
+        def code_obj
+          first_identifier&.code_obj
+        end
+
+        # See AdoptedStandard#mr_year — without it the 1989 and the 1993
+        # printings of "IEEE Std 960 and IEEE Std 1177" shared one slug.
+        def mr_year
+          (year || first_identifier&.year)&.to_s
+        end
+
+        # `#publisher` above returns an ARRAY, and the inherited `mr_publisher`
+        # is `publisher&.to_s&.downcase` — so the MR slug contained a literal
+        # Ruby array (`["ieee", "asme"]`, brackets, quotes, comma and space
+        # included) and `to_slug` is an output FILENAME. Join the two instead,
+        # keeping both publishers in the slug: they are equally part of this
+        # document's identity, so by the project rule both must reach it.
+        def mr_publisher
+          names = Array(publisher).map { |p| p.to_s.downcase }.reject(&:empty?)
+          names.empty? ? nil : names.join("-")
+        end
       end
     end
   end

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

@@ -10,6 +10,29 @@ module Pubid
         # Uniform `year` (the interpretation year), not `int_year` — inherited
         # from the base, so no attribute is declared here.
 
+        # The interpreted standard's code must reach the URN. Before this
+        # change the flat-parsed form kept its number in the wrapper's own
+        # `code_obj` (the builder never built a base), so the URN carried it by
+        # accident; now that the number lives on `base` where it belongs, the
+        # URN generator has to be pointed at it or the URN silently loses the
+        # document number. `code_obj` is a plain attr_accessor, not a lutaml
+        # attribute, so overriding it as a method is safe.
+        def code_obj
+          super || base&.code_obj
+        end
+
+        # MR supplement suffix: `int.{year}` — mirrors Corrigendum/Amendment.
+        # Without it the MrString renderer slugs an interpretation FLAT off
+        # attributes a supplement does not have, instead of recursing into
+        # `base`, so every interpretation of every standard collapsed onto
+        # "ieee.std.{year}" with no document number at all — and `to_slug` is
+        # an output FILENAME.
+        def mr_supplement_suffix
+          segments = ["int"]
+          segments << year.to_s if year
+          segments.join(".")
+        end
+
         # TYPED_STAGES for interpretation
         # Interpretation uses "INT" abbreviation
         TYPED_STAGES = [

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

@@ -93,7 +93,9 @@ module Pubid
         # @param format [Symbol] :ieee or :iso (defaults to canonical_format)
         # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
         # @return [String] formatted identifier
-        def to_s(format: canonical_format, trademark: false)
+        # `**_opts` absorbs render flags this list does not name (`annotated:`),
+        # which the closed keyword list used to reject outright.
+        def to_s(format: canonical_format, trademark: false, **opts)
           # The mark goes after the code number, before the draft and the year
           # ("ISO/IEC/IEEE P26511™/D8-2018"), so it is threaded into the
           # format builders rather than appended to the finished string.
@@ -105,12 +107,14 @@ module Pubid
                    ""
                  end
 
-          case format
-          when :iso
-            to_iso_format(mark)
-          else
-            to_ieee_format(mark)
-          end
+          result = case format
+                   when :iso
+                     to_iso_format(mark)
+                   else
+                     to_ieee_format(mark)
+                   end
+
+          annotate_plain_render(result, **opts)
         end
 
         private

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

@@ -9,12 +9,41 @@ module Pubid
       # - "IEEE Std 1299/C62.22.1-1996" (same document, two numbers)
       # - "IEEE Std 960-1989, Std 1177-1989" (same document, two numbers)
       class MultiNumberedIdentifier < Identifier
-        # Primary identifier (main IEEE standard number)
-        # Stored as-is (Lutaml model type checking doesn't work with polymorphic identifiers)
-        attr_accessor :primary_identifier
+        # Both designations are real lutaml attributes.
+        #
+        # They used to be `attr_accessor`s, which lutaml cannot see — so
+        # `to_hash` emitted {"_type" => "pubid:ieee:multi-numbered-identifier"}
+        # and NOTHING else, `from_hash` could not rebuild either member, and
+        # `#exclude` (which iterates self.class.attributes) skipped them. The
+        # whole identity was dropped. That is the CSA container defect recorded
+        # in CLAUDE.md, and the fix is the same: make the members attributes.
+        #
+        # The type is the CROSS-FLAVOR ::Pubid::Identifier, not IEEE's own:
+        # `polymorphic: true` widens only to subclasses, and the second
+        # designation may belong to another body — the same reason
+        # AdoptedStandard's members carry that type.
+        attribute :primary_identifier, ::Pubid::Identifier, polymorphic: true
+        attribute :secondary_identifier, ::Pubid::Identifier, polymorphic: true
 
-        # Secondary identifier (additional number for same document)
-        attr_accessor :secondary_identifier
+        # One document under two numbers, neither of them held here, so
+        # `root.number` was "". Walk to the primary designation.
+        def root
+          primary_identifier ? primary_identifier.root : self
+        end
+
+        # Carry the number onto the URN and the MR slug as well as #root — see
+        # AdoptedStandard#code_obj.
+        def code_obj
+          primary_identifier&.code_obj
+        end
+
+        # See AdoptedStandard#mr_year. `year` below already delegates, so this
+        # only stringifies — it is kept explicit so the hook survives if that
+        # delegation is ever removed in favour of the URN generator's
+        # `year_component` root fallback.
+        def mr_year
+          year&.to_s
+        end
 
         def publisher
           primary_identifier&.publisher
@@ -27,6 +56,29 @@ module Pubid
         def year
           primary_identifier&.year
         end
+
+        # `publisher` and `year` are DERIVED from primary_identifier — and,
+        # since that member became a serialized attribute above, the derived
+        # values are now re-emitted after from_hash materializes the attribute
+        # defaults, while the parse path omits them as unset. That asymmetry
+        # breaks `from_hash(to_hash) == to_hash`, the gate relaton's index
+        # build uses to decide whether to keep a document.
+        #
+        # It is latent rather than live for the one corpus id (its primary is
+        # IEEE-published with no year, so both derived values match their
+        # defaults and are dropped anyway), but the class documents that its
+        # members may belong to another body — and a synthetic AIEE primary
+        # reproduces it immediately. Dropping the keys is lossless:
+        # primary_identifier rebuilds both. Same treatment as
+        # AdoptedStandard#to_hash and DualPublished#to_hash.
+        def to_hash(*args)
+          hash = super
+          return hash unless hash.is_a?(::Hash)
+
+          hash.delete("publisher")
+          hash.delete("year")
+          hash
+        end
       end
     end
   end

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

@@ -88,10 +88,10 @@ module Pubid
           #
           # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] String representation
-          def to_s(trademark: false)
+          def to_s(trademark: false, **opts)
             result = ["IEEE Std", year, name_portion].compact.join(" ")
             result += trademark_symbol if trademark
-            result
+            annotate_plain_render(result, **opts)
           end
 
           # Trademark symbol for this document's own code. A NESC string starts

data/lib/pubid/ieee/identifiers/nesc/draft.rb

@@ -29,12 +29,12 @@ module Pubid
           #
           # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] Draft format with optional month and year
-          def to_s(trademark: false)
+          def to_s(trademark: false, **opts)
             parts = ["Draft National Electrical Safety Code"]
             parts << ", #{month} #{year}" if month && year
             result = parts.join
             result += trademark_symbol if trademark
-            result
+            annotate_plain_render(result, **opts)
           end
         end
       end