pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

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

@@ -4,6 +4,129 @@ module Pubid
   module Csa
     module Identifiers
       class Base < SingleIdentifier
+        def to_s
+          prefix = publisher_prefix || "CSA"
+
+          # Handle code_only identifiers (empty string means no prefix)
+          if prefix == ""
+            # No prefix for code_only identifiers
+            parts = []
+          else
+            # Determine if we need space after prefix
+            # CAN/CSA- and CAN3- end with dash, so no space needed
+            needs_space = !prefix.end_with?("-")
+
+            parts = []
+            parts << prefix
+          end
+
+          # Code and year together
+          code_part = code.to_s if code
+
+          # NO. keyword
+          if no_number
+            code_part += " NO. #{no_number}"
+          end
+
+          # Series prefix and keyword (before year)
+          if series_prefix
+            code_part += " #{series_prefix} SERIES"
+          elsif series
+            # SERIES without prefix
+            code_part += " SERIES"
+          end
+
+          parts << code_part if code_part
+
+          # Year with proper format (colon or dash)
+          if year
+            # Use dash if year_format is dash, otherwise colon
+            separator = year_format == "dash" ? "-" : ":"
+            year_part = separator
+            year_part += year_prefix if year_prefix # Add M or F prefix
+            year_part += "F" if french && year_format != "dash" && !year_prefix # Only add F if no prefix
+            # Convert 4-digit year back to 2-digit for M/F prefix preservation
+            # M1983 → M83, F1983 → F83, 1983 → 83, 20xx → xx
+            # However, preserve original 4-digit format if the input was 4-digit (original_year_4digit)
+            year_str = year.to_s
+            year_part += if original_year_4digit
+                           # Preserve 4-digit format (e.g., "M1981" stays "M1981")
+                           year_str
+                         elsif year_prefix&.match?(/^[MF]$/) && year_str.length == 4 && year_str.start_with?("19")
+                           # M/F + 4-digit year (1900s) → convert to 2-digit with prefix
+                           year_str[2..3]
+                         elsif year_str.length == 4 && year_str.start_with?("20")
+                           # 2000s → just last 2 digits
+                           year_str[2..3]
+                         elsif year_str.length == 4 && year_str.start_with?("19") && !original_year_4digit
+                           # 1900s with no M/F prefix, but original was 2-digit (e.g., CAN3-Z299.0-86)
+                           # Convert back to 2-digit
+                           year_str[2..3]
+                         else
+                           # Other formats - keep as-is
+                           year_str
+                         end
+            parts[-1] += year_part
+          end
+
+          result = if prefix == ""
+                     # No prefix, just join parts
+                     parts.join(" ")
+                   elsif needs_space
+                     parts.join(" ")
+                   elsif parts.length == 2
+                     # No space after dash-ending prefix - join first two parts directly
+                     # If there are more parts after code, they should still have spaces
+                     parts.join
+                   else
+                     # More than 2 parts shouldn't happen in current design
+                     parts.join
+                   end
+
+          # Reaffirmation - preserve original format and determine spacing
+          if reaffirmation
+            # Check if year was originally 2-digit (original_year_4digit flag)
+            year_was_2digit = !original_year_4digit
+
+            # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
+            reaffirmation_was_4digit = original_reaffirmation_4digit
+
+            # Preserve original reaffirmation format
+            # If original was 4-digit, keep as 4-digit
+            # If original was 2-digit, convert from 4-digit storage back to 2-digit
+            reaffirmation_str = if reaffirmation_was_4digit
+                                  # Original was 4-digit, keep as-is
+                                  reaffirmation.to_s
+                                elsif reaffirmation.to_s.length == 4 && reaffirmation.to_s.start_with?(
+                                  "19", "20"
+                                )
+                                  # Original was 2-digit, convert 4-digit storage back to 2-digit
+                                  # (R2004) → (R04), (R1994) → (R94)
+                                  reaffirmation.to_s[2..3]
+                                else
+                                  # Already 2-digit or other format
+                                  reaffirmation.to_s
+                                end
+
+            # Determine spacing based on original formats
+            # Space needed if year is 2-digit and reaffirmation is 4-digit (original format)
+            # No space if both year and reaffirmation are 2-digit, or both are 4-digit
+            if year_was_2digit && reaffirmation_was_4digit
+              # Year was 2-digit, reaffirmation was 4-digit → add space
+              result += " (R#{reaffirmation_str})"
+            else
+              # Both 2-digit, both 4-digit, or other cases → no space
+              result += "(R#{reaffirmation_str})"
+            end
+          end
+
+          # Package (already has leading space from parser)
+          if package
+            result += package
+          end
+
+          result
+        end
       end
     end
   end

data/lib/pubid/csa/identifiers/bundled.rb

@@ -5,33 +5,17 @@ require "lutaml/model"
 module Pubid
   module Csa
     module Identifiers
-      class Bundled < Identifier
-        # The consolidated base document and the amendments bundled with it.
-        # Both are typed cross-flavor and polymorphic — see
-        # WrapperIdentifier#base — because a bundle's base is routinely a Cec,
-        # which is not a Standard subclass. #root is inherited: it walks
-        # `base` to the origin document.
-        attribute :base, ::Pubid::Identifier, polymorphic: true
-        attribute :bundled_with, ::Pubid::Identifier, polymorphic: true,
-                                                      collection: true
+      class Bundled < Lutaml::Model::Serializable
+        attribute :base, Standard
+        attribute :bundled_with, Standard, collection: true
         attribute :reaffirmation, :string
         attribute :original_reaffirmation_4digit, :boolean, default: -> {
           false
         }
         attribute :year_format, :string # Add for compatibility with identifier.rb
 
-        # A bundle is a base document consolidated with its amendments, so
-        # both matching primitives peel to that base.
-        def base_document
-          base ? base.base_document : self
-        end
-
-        def drop_supplements
-          base || self
-        end
-
-        def to_s(**opts)
-          # For Cec identifiers, use normalized form (number instead of cec_part + NO.)
+        def to_s
+          # For Cec identifiers, use normalized form (code instead of cec_part + NO.)
           # This is used for "normalized form" rendering in bundled identifiers
           if base.is_a?(Cec)
             # Render base with normalized code format
@@ -47,7 +31,7 @@ module Pubid
                              end
                            end
             base_str = (needs_space ? "#{prefix} " : prefix) +
-              base.number.value.to_s + # Normalized code (e.g. "C22.2-1")
+              base.code.value.to_s + # Use normalized code (e.g., "C22.2-1")
               ":#{year_display}"
             parts = [base_str]
           else
@@ -60,7 +44,7 @@ module Pubid
             bundled_with.each do |bundled|
               # For Cec identifiers, use normalized code format
               if bundled.is_a?(Cec)
-                bundled_part = bundled.number.value.to_s # e.g. "C22.2-2"
+                bundled_part = bundled.code.value.to_s # Normalized code (e.g., "C22.2-2")
                 if bundled.year
                   # Use dash if year_format is dash, otherwise colon
                   separator = bundled.year_format == "dash" ? "-" : ":"
@@ -78,7 +62,7 @@ module Pubid
               else
                 # Standard rendering for other identifier types
                 bundled_part = ""
-                bundled_part += bundled.number.to_s if bundled.number
+                bundled_part += bundled.code.to_s if bundled.code
 
                 if bundled.year
                   # Use dash if year_format is dash, otherwise colon
@@ -133,7 +117,7 @@ module Pubid
                       end
           end
 
-          annotate_plain_render(result, **opts)
+          result
         end
       end
     end

data/lib/pubid/csa/identifiers/canadian_adopted.rb

@@ -12,40 +12,40 @@ module Pubid
       #
       # This is a wrapper pattern where:
       #   - CAN/ indicates Canadian adoption
-      #   - The base is the actual CSA standard being adopted
+      #   - The wrapped_identifier is the actual CSA standard being adopted
       #
       # This is semantically different from a string prefix because:
       #   - CAN/ wraps an entire identifier (which may itself be complex)
       #   - The wrapped identifier is recursively parsed as a full CSA identifier
       #   - Proper object composition, not string manipulation
       class CanadianAdopted < WrapperIdentifier
-        def to_s(**opts)
+        def to_s
           # For CAN3- identifiers, don't add CAN/ prefix (CAN3- is already complete)
           # For Series with CAN/CSA- prefix, don't add CAN/ (it's already complete)
           # For CAN/CSA- identifiers, CAN/ wraps CSA- part
-          if base.class.attributes.key?(:publisher_prefix) && base.publisher_prefix
-            prefix = base.publisher_prefix
+          if wrapped_identifier.class.attributes.key?(:publisher_prefix) && wrapped_identifier.publisher_prefix
+            prefix = wrapped_identifier.publisher_prefix
             # CAN3- is standalone, just render wrapped identifier
             # CAN/CSA- is already complete for Series identifiers
-            if prefix == "CAN3-" || (prefix == "CAN/CSA-" && base.is_a?(Identifiers::Series))
-              result = base.to_s
+            if prefix == "CAN3-" || (prefix == "CAN/CSA-" && wrapped_identifier.is_a?(Identifiers::Series))
+              result = wrapped_identifier.to_s
             else
               # For other cases, prepend CAN/ prefix
-              result = "CAN/#{base}"
+              result = "CAN/#{wrapped_identifier}"
             end
           else
             # No publisher_prefix, prepend CAN/
-            result = "CAN/#{base}"
+            result = "CAN/#{wrapped_identifier}"
           end
-          # Only add reaffirmation from wrapper if base doesn't have one
+          # Only add reaffirmation from wrapper if wrapped_identifier doesn't have one
           # (to avoid duplicates - Identifier.parse sets it on both)
-          if reaffirmation && !(base.class.attributes.key?(:reaffirmation) && base.reaffirmation)
+          if reaffirmation && !(wrapped_identifier.class.attributes.key?(:reaffirmation) && wrapped_identifier.reaffirmation)
             # Determine if space is needed before reaffirmation
             # Space needed if year is 2-digit and reaffirmation is 4-digit (original format)
             # No space if both year and reaffirmation are 2-digit
             # Check original_year_4digit flag - if false, year was originally 2-digit
-            year_was_2digit = base.class.attributes.key?(:original_year_4digit) &&
-              !base.original_year_4digit
+            year_was_2digit = wrapped_identifier.class.attributes.key?(:original_year_4digit) &&
+              !wrapped_identifier.original_year_4digit
             # Check original_reaffirmation_4digit flag
             reaffirmation_was_4digit = original_reaffirmation_4digit
 
@@ -74,7 +74,7 @@ module Pubid
               result += "(R#{reaffirmation_str})"
             end
           end
-          annotate_plain_render(result, **opts)
+          result
         end
       end
     end

data/lib/pubid/csa/identifiers/cec.rb

@@ -13,52 +13,115 @@ module Pubid
         attribute :cec_part, Components::Code      # C22.2, C22.3, C22.4, C22.6
         attribute :no_number, Components::Code     # Number after NO.
 
-        # `CSA C22.2 NO. 286:23` stores the joined "C22.2-286" in `number`, which
-        # appears nowhere in the printed form; the two halves it does print live
-        # in `cec_part` and `no_number`. Naming them gives the identifier its
-        # docnumber spans back.
-        def annotation_tokens
-          super + [
-            [:publisher_prefix, "publisher"],
-            [:cec_part, "docnumber"],
-            [:no_number, "docnumber"],
-          ]
-        end
+        # Combined code attribute for compatibility
+        # Returns cec_part + "-" + no_number (e.g., "C22.2-1")
+        def code
+          return nil unless cec_part && no_number
 
-        # Merged with SingleIdentifier's block (lutaml combines an inherited
-        # key_value block with a subclass one), so this adds only the half of
-        # the code that Cec keeps separately.
-        key_value do
-          map "cec_part",
-              with: { to: :cec_part_to_kv, from: :cec_part_from_kv }
+          @code ||= Components::Code.new(value: "#{cec_part.value}-#{no_number.value}")
         end
 
-        def cec_part_to_kv(model, doc)
-          emit_kv(doc, "cec_part", model.cec_part)
-        end
+        def to_s
+          parts = []
 
-        def cec_part_from_kv(model, value)
-          model.cec_part = Components::Code.new(value: value.to_s)
-        end
+          # Publisher prefix (CSA, CAN/CSA-, CAN3-)
+          prefix = publisher_prefix || "CSA"
 
-        # The document code, synthesised from its two halves:
-        # cec_part + "-" + no_number (e.g. "C22.2-1"). This is the index key.
-        #
-        # It shadows the reader lutaml generates for the inherited `number`
-        # attribute, which is safe because Cec declares no `number` of its own
-        # — the ITU precedent (itu/identifiers/base.rb). `cec_part` and
-        # `no_number` are themselves serialized, so from_hash reproduces the
-        # synthesised value.
-        #
-        # Deliberately NOT memoised: `@number` is the very ivar lutaml uses to
-        # store the inherited attribute, so caching there would both discard a
-        # value assigned through the generated writer and go stale if
-        # `cec_part`/`no_number` were reassigned — and `number` is the relaton
-        # index key. The concatenation is trivial, so there is nothing to save.
-        def number
-          return nil unless cec_part && no_number
+          # Determine if we need space after prefix
+          # CAN/CSA- and CAN3- end with dash, so no space needed
+          needs_space = !prefix.end_with?("-")
+
+          parts << prefix unless prefix == ""
+
+          # CEC Part (C22.2, C22.3, etc.)
+          parts << cec_part.value if cec_part
+
+          # NO. notation - this is the key semantic component
+          parts << "NO."
+
+          # Number after NO.
+          parts << no_number.value if no_number
+
+          # Determine separator based on prefix ending
+          result = if prefix == ""
+                     parts.join(" ")
+                   elsif needs_space
+                     parts.join(" ")
+                   elsif parts.length <= 2
+                     # No space after dash-ending prefix (CAN/CSA-, CAN3-)
+                     # Join first two parts directly, rest with spaces
+                     parts.join
+                   else
+                     parts[0] + parts[1..].join(" ")
+                   end
+
+          # Year with proper format (colon or dash)
+          if year
+            # Use dash if year_format is dash, otherwise colon
+            separator = year_format == "dash" ? "-" : ":"
+            year_part = separator
+
+            # Convert 4-digit year back to 2-digit for display
+            year_str = year.to_s
+            display_year = if year_str.length == 4 && year_str.start_with?("20")
+                             year_str[2..3]
+                           elsif year_str.length == 4 && year_str.start_with?("19")
+                             year_str[2..3]
+                           else
+                             year_str
+                           end
+
+            # Add prefix if present
+            year_part += if year_prefix
+                           year_prefix + display_year
+                         elsif french && year_format != "dash"
+                           # Only add F if no prefix already set
+                           "F#{display_year}"
+                         else
+                           display_year
+                         end
+
+            result += year_part
+          end
+
+          # Reaffirmation - preserve original format and determine spacing
+          if reaffirmation
+            # Check if year was originally 2-digit (original_year_4digit flag)
+            year_was_2digit = !original_year_4digit
+
+            # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
+            reaffirmation_was_4digit = original_reaffirmation_4digit
+
+            # Preserve original reaffirmation format
+            # If original was 4-digit, keep as 4-digit
+            # If original was 2-digit, convert from 4-digit storage back to 2-digit
+            reaffirmation_str = if reaffirmation_was_4digit
+                                  # Original was 4-digit, keep as-is
+                                  reaffirmation.to_s
+                                elsif reaffirmation.to_s.length == 4 && reaffirmation.to_s.start_with?(
+                                  "19", "20"
+                                )
+                                  # Original was 2-digit, convert 4-digit storage back to 2-digit
+                                  # (R2004) → (R04), (R1994) → (R94)
+                                  reaffirmation.to_s[2..3]
+                                else
+                                  # Already 2-digit or other format
+                                  reaffirmation.to_s
+                                end
+
+            # Determine spacing based on original formats
+            # Space needed if year is 2-digit and reaffirmation is 4-digit (original format)
+            # No space if both year and reaffirmation are 2-digit, or both are 4-digit
+            if year_was_2digit && reaffirmation_was_4digit
+              # Year was 2-digit, reaffirmation was 4-digit → add space
+              result += " (R#{reaffirmation_str})"
+            else
+              # Both 2-digit, both 4-digit, or other cases → no space
+              result += "(R#{reaffirmation_str})"
+            end
+          end
 
-          Components::Code.new(value: "#{cec_part.value}-#{no_number.value}")
+          result
         end
       end
     end

data/lib/pubid/csa/identifiers/combined.rb

@@ -5,23 +5,16 @@ require "lutaml/model"
 module Pubid
   module Csa
     module Identifiers
-      # Combined represents CSA identifiers joined with "/" or ", "
+      # CombinedIdentifier represents CSA identifiers combined with "/" separator
       # Examples:
       #   CSA A23.1:24/CSA A23.2:24
       #   CSA N285.0:23/CSA N285.6 SERIES:23
       #   CSA A123.1-05/A123.5-05 (R2015)
       #   CSA B44:19/B44.1:19/B44.2:19 (triple combined)
-      class Combined < Identifier
-        # The co-equal designations, in printed order.
-        #
-        # One polymorphic collection, the IEC ConsolidatedIdentifier shape —
-        # not the historical first/second/third triple, which hard-capped the
-        # form at three and froze a non-standard hash shape. The first member
-        # is the primary designation, which is what #root walks so the index
-        # key is non-empty. Typed cross-flavor for the same reason as
-        # WrapperIdentifier#base.
-        attribute :identifiers, ::Pubid::Identifier, polymorphic: true,
-                                                     collection: true
+      class Combined < Lutaml::Model::Serializable
+        attribute :first, Standard
+        attribute :second, Standard
+        attribute :third, Standard
         attribute :reaffirmation, :string
         attribute :original_reaffirmation_4digit, :boolean, default: -> {
           false
@@ -30,74 +23,61 @@ module Pubid
         attribute :year_format, :string # Dummy for compatibility
         attribute :separator, :string, default: -> { "/" } # "/" or ", "
 
-        # A combined id stores its members in `identifiers`, not `base`, so
-        # walk the primary designation to the origin document
-        # (Iec::Identifiers::ConsolidatedIdentifier does the same).
-        def root
-          identifiers&.first&.root || self
-        end
+        def to_s
+          # For comma separator, render both parts with full prefix
+          # For slash separator, second/third parts without prefix
+          if separator == ", "
+            # Comma: Both with full CSA prefix
+            parts = [first.to_s, second.to_s]
+            parts << third.to_s if third
+          else
+            # Slash: Second and third without CSA prefix (continuation)
+            parts = [first.to_s]
+            parts << render_continuation(second)
+            parts << render_continuation(third) if third
+          end
 
-        # Co-equal designations, so both matching primitives reduce to the
-        # primary one — the Iec::Identifiers::ConsolidatedIdentifier shape.
-        def base_document
-          identifiers&.first&.base_document || self
-        end
+          result = parts.join(separator || "/")
 
-        def drop_supplements
-          identifiers&.first || self
-        end
+          # Reaffirmation - preserve original format and determine spacing
+          if reaffirmation
+            # For combined identifiers, check year format from first identifier
+            # to determine spacing
+            year_was_2digit = first.class.attributes.key?(:original_year_4digit) && !first.original_year_4digit
+
+            # Check if reaffirmation was originally 4-digit
+            # Note: We need to track this at the Combined level, but for now
+            # assume 4-digit if the value is 4 digits and starts with 19/20
+            reaffirmation_was_4digit = reaffirmation.to_s.length == 4 &&
+              reaffirmation.to_s.start_with?("19", "20")
+
+            # Determine spacing based on original formats
+            # Space needed if year is 2-digit and reaffirmation is 4-digit
+            result += if year_was_2digit && reaffirmation_was_4digit
+                        " (R#{reaffirmation})"
+                      else
+                        "(R#{reaffirmation})"
+                      end
+          end
 
-        def to_s(**opts)
-          parts = render_parts
-          result = parts.join(separator || "/")
-          result += render_reaffirmation if reaffirmation
           result += package if package
-          annotate_plain_render(result, **opts)
+          result
         end
 
         private
 
-        # With a comma separator every designation carries its full prefix;
-        # with a slash the trailing ones are continuations printed bare.
-        def render_parts
-          return identifiers.map(&:to_s) if separator == ", "
-
-          identifiers.each_with_index.map do |identifier, index|
-            index.zero? ? identifier.to_s : render_continuation(identifier)
-          end
-        end
-
-        # Reaffirmation - preserve original format and determine spacing.
-        # A space is needed when the year was printed 2-digit and the
-        # reaffirmation 4-digit; the year format comes from the primary
-        # designation.
-        def render_reaffirmation
-          primary = identifiers&.first
-          year_was_2digit =
-            primary &&
-            primary.class.attributes.key?(:original_year_4digit) &&
-            !primary.original_year_4digit
-
-          reaffirmation_was_4digit = reaffirmation.to_s.length == 4 &&
-            reaffirmation.to_s.start_with?("19", "20")
-
-          if year_was_2digit && reaffirmation_was_4digit
-            " (R#{reaffirmation})"
-          else
-            "(R#{reaffirmation})"
-          end
-        end
-
         # Render identifier without CSA prefix (unless has_publisher is true)
         def render_continuation(identifier)
           parts = []
 
           # Add CSA prefix if present in original
           if identifier.has_publisher
-            parts << (identifier.publisher_prefix || "CSA")
+            prefix = identifier.publisher_prefix || "CSA"
+            !prefix.end_with?("-")
+            parts << prefix
           end
 
-          code_part = identifier.number.to_s if identifier.number
+          code_part = identifier.code.to_s if identifier.code
 
           # NO. keyword
           if identifier.no_number
@@ -112,42 +92,34 @@ module Pubid
             code_part += " SERIES"
           end
 
-          code_part += render_continuation_year(identifier) if identifier.year
-
-          parts << code_part if code_part
-
-          join_continuation(identifier, parts)
-        end
-
-        # Year with proper format (colon or dash)
-        def render_continuation_year(identifier)
-          separator = identifier.year_format == "dash" ? "-" : ":"
-          year_part = separator
-          # Add M or F prefix
-          year_part += identifier.year_prefix if identifier.year_prefix
-          # Only add F if no prefix
-          if identifier.french && identifier.year_format != "dash" &&
-              !identifier.year_prefix
-            year_part += "F"
+          # Year with proper format (colon or dash)
+          if identifier.year
+            separator = identifier.year_format == "dash" ? "-" : ":"
+            year_part = separator
+            year_part += identifier.year_prefix if identifier.year_prefix # Add M or F prefix
+            year_part += "F" if identifier.french && identifier.year_format != "dash" && !identifier.year_prefix # Only add F if no prefix
+            # Convert 4-digit year back to 2-digit
+            year_str = identifier.year.to_s
+            year_part += if year_str.length == 4 && year_str.start_with?("20")
+                           year_str[2..3]
+                         else
+                           year_str
+                         end
+            code_part += year_part
           end
-          # Convert 4-digit year back to 2-digit
-          year_str = identifier.year.to_s
-          year_part + if year_str.length == 4 && year_str.start_with?("20")
-                        year_str[2..3]
-                      else
-                        year_str
-                      end
-        end
 
-        # Join with proper spacing based on prefix
-        def join_continuation(identifier, parts)
-          return parts.join(" ") unless identifier.has_publisher &&
-            parts.length > 1
+          parts << code_part if code_part
 
-          prefix = parts[0]
-          if prefix.end_with?("-")
-            # No space after dash-ending prefix
-            prefix + parts[1..].join(" ")
+          # Join with proper spacing based on prefix
+          if identifier.has_publisher && parts.length > 1
+            prefix = parts[0]
+            needs_space = !prefix.end_with?("-")
+            if needs_space
+              parts.join(" ")
+            else
+              # No space after dash-ending prefix
+              parts[0] + parts[1..].join(" ")
+            end
           else
             parts.join(" ")
           end

data/lib/pubid/csa/identifiers/csa_adopted.rb

@@ -18,16 +18,16 @@ module Pubid
       #
       # This is a wrapper pattern where:
       #   - CSA prefix indicates adoption
-      #   - The base is the external standard (ISO/IEC/CISPR)
+      #   - The wrapped_identifier is the external standard (ISO/IEC/CISPR)
       #   - Wrapped identifier is recursively parsed using external flavor parsers
       class CsaAdopted < WrapperIdentifier
         # Publisher prefix (e.g., "CSA-", "CAN3-") for rendering
         # When set, uses dash format without space (e.g., "CSA-ISO" not "CSA ISO")
         attribute :publisher_prefix, :string
 
-        def to_s(**opts)
+        def to_s
           # Get string representation from wrapped identifier
-          base_str = base.to_s
+          base_str = wrapped_identifier.to_s
 
           # Convert 4-digit years to 2-digit for CSA adoption format
           # ISO/IEC TR 12785-3:2015 → ISO/IEC TR 12785-3:15
@@ -70,7 +70,7 @@ module Pubid
           # Append reaffirmation if present
           result += " (R#{reaffirmation})" if reaffirmation
 
-          annotate_plain_render(result, **opts)
+          result
         end
       end
     end