pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.11

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.
@@ -770,9 +809,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"

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

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

@@ -27,14 +27,14 @@ module Pubid
           #
           # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] YYYY NESC Handbook format with optional edition
-          def to_s(trademark: false)
+          def to_s(trademark: false, **opts)
             abbr = "NESC"
             abbr += "(R)" if registered
             parts = [["IEEE Std", year, "#{abbr} Handbook"].compact.join(" ")]
             parts << ", #{edition}" if edition
             result = parts.join
             result += trademark_symbol if trademark
-            result
+            annotate_plain_render(result, **opts)
           end
         end
       end

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

@@ -23,10 +23,10 @@ module Pubid
           #
           # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] YYYY NESC Redline format
-          def to_s(trademark: false)
+          def to_s(trademark: false, **opts)
             result = [year, "NESC Redline"].compact.join(" ")
             result += trademark_symbol if trademark
-            result
+            annotate_plain_render(result, **opts)
           end
         end
       end

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

@@ -26,13 +26,13 @@ module Pubid
           # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] C2-YYYY format (bare "C2" when the year is absent,
           #   e.g. a partial reference produced by `#exclude(:year)`)
-          def to_s(trademark: false)
+          def to_s(trademark: false, **opts)
             # Unlike the year-first NESC editions, this form renders a code, so
             # the mark goes after it and before the year — as everywhere else.
             code_part = "C2"
             code_part += trademark_symbol if trademark
             code_part += "-#{year}" if year
-            "#{code_part} National Electrical Safety Code"
+            annotate_plain_render("#{code_part} National Electrical Safety Code", **opts)
           end
         end
       end

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

@@ -44,7 +44,7 @@ module Pubid
           builder.build(parsed)
         end
 
-        def to_s(trademark: false)
+        def to_s(trademark: false, **opts)
           # Year comes FIRST in IRE format - render as 2-digit short year
           result = [(short_year if year), publisher, type, code&.to_s]
             .compact.join(" ")
@@ -56,7 +56,7 @@ module Pubid
                                                        code_obj&.prefix,
                                                        publishers: [publisher])
           end
-          result
+          annotate_plain_render(result, **opts)
         end
 
         private

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

@@ -7,7 +7,7 @@ module Pubid
     module Ire
       # Parser for IRE (Institute of Radio Engineers) identifiers
       # Historical period: 1912-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/nesc/parser.rb

@@ -20,7 +20,7 @@ module Pubid
       # @example Parse handbook
       #   parser = Parser.new
       #   result = parser.parse("2017 NESC Handbook, Premier Edition")
-      class Parser < Parslet::Parser
+      class Parser < ::Pubid::Parser::Grammar
         root(:nesc_identifier)
 
         rule(:space) { str(" ") }

data/lib/pubid/ieee/parser.rb

@@ -7,7 +7,7 @@ module Pubid
     # Parser class for IEEE identifiers
     # Single Responsibility: Parsing IEEE identifier syntax
     # Note: IEEE is extremely complex with many edge cases
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:space?) { space.maybe }

data/lib/pubid/ieee/renderer.rb

@@ -320,7 +320,11 @@ module Pubid
 
         secondary_code = id.secondary_identifier.code.to_s
         if secondary_code.start_with?("C") && secondary_code.match?(/^C\d+\./)
-          "#{primary}/#{secondary}"
+          # A cross-reference prints the bare second designation after the
+          # slash — "IEEE Std 1299/C62.22.1-1996" — not a second full
+          # reference, so this branch must not reuse `secondary`, which
+          # carries its own "IEEE Std " prefix.
+          "#{primary}/#{secondary_code}"
         else
           "#{primary} and #{secondary}"
         end