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

data/lib/pubid/astm.rb

@@ -1,55 +1,38 @@
 # frozen_string_literal: true
 
+require "parslet"
+require "lutaml/model"
+require_relative "identifier"
+require_relative "astm/identifier"
+require_relative "astm/components/code"
+require_relative "astm/single_identifier"
+require_relative "astm/parser"
+require_relative "astm/builder"
+
+# Identifier classes
+require_relative "astm/identifiers/base"
+require_relative "astm/identifiers/standard"
+require_relative "astm/identifiers/iso_dual_published"
+require_relative "astm/identifiers/manual"
+require_relative "astm/identifiers/research_report"
+require_relative "astm/identifiers/data_series"
+require_relative "astm/identifiers/technical_report"
+require_relative "astm/identifiers/monograph"
+require_relative "astm/identifiers/adjunct"
+require_relative "astm/identifiers/work_in_progress"
+
+# Scheme (must be loaded after identifiers)
+require_relative "astm/scheme"
+
 module Pubid
   module Astm
-    extend Pubid::PrefixesSupport
-
-    # Sole ASTM publisher token (see the parser's `publisher` rule).
-    PREFIXES = ["ASTM"].freeze
-
-    autoload :Components, "#{__dir__}/astm/components"
-    autoload :Identifier, "#{__dir__}/astm/identifier"
-    autoload :Identifiers, "#{__dir__}/astm/identifiers"
-    autoload :SingleIdentifier, "#{__dir__}/astm/single_identifier"
-    autoload :Parser, "#{__dir__}/astm/parser"
-    autoload :Builder, "#{__dir__}/astm/builder"
-    autoload :Renderer, "#{__dir__}/astm/renderer"
-    autoload :UrnGenerator, "#{__dir__}/astm/urn_generator"
-    autoload :UrnParser, "#{__dir__}/astm/urn_parser"
-
     def self.parse(str)
       Identifier.parse(str)
     end
-
-    def self.identifier_types
-      @identifier_types ||= Identifiers.constants
-        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
-        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
-        .select { |c| c.type.is_a?(Hash) }
-    end
-
-    def self.all_typed_stages
-      @all_typed_stages ||= identifier_types.flat_map do |klass|
-        if klass.const_defined?(:TYPED_STAGES)
-          klass.const_get(:TYPED_STAGES)
-        else
-          []
-        end
-      end
-    end
-
-    def self.locate_type(code)
-      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
-    end
-
-    def self.locate_stage(abbr)
-      abbr_str = abbr.to_s.upcase
-      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
-    end
   end
+
+  # Register this flavor with the Pubid registry
 end
 
+# Register Uastm flavor with the registry
 Pubid::Registry.register(:astm, Pubid::Astm)
-
-Pubid::Astm::SingleIdentifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::Astm::SingleIdentifier.format_registry.register(:human, renderer: Pubid::Astm::Renderer)

data/lib/pubid/bsi/builder.rb

@@ -3,19 +3,12 @@
 module Pubid
   module Bsi
     class Builder < Pubid::Builder::Base
-      # Default typed stage used when an abbreviation lookup yields no match.
-      # Empty/unknown abbreviations fall back to the published British Standard.
-      DEFAULT_TYPED_STAGE = Pubid::Components::TypedStage.new(
-        code: :pubbs,
-        stage_code: :published,
-        type_code: :bs,
-        abbr: ["BS"],
-        name: "British Standard",
-        harmonized_stages: %w[60.00 60.60],
-      ).freeze
-
-      def self.build(parsed_data)
-        new.build(parsed_data)
+      def initialize(scheme)
+        @scheme = scheme
+      end
+
+      def self.build(parsed_data, scheme = Scheme.new)
+        new(scheme).build(parsed_data)
       end
 
       def build(data)
@@ -114,14 +107,22 @@ module Pubid
         if data[:na_prefix]
           return build_national_annex(data, supplements_data)
         elsif data[:adopted_string]
-          # Adopted identifiers carry their supplements and Expert-commentary
-          # suffix *inside* the adopted string, so build_adopted_identifier does
-          # all the wrapping. Wrapping again here would double-wrap (a second
-          # ExpertCommentary around the first) and break #base_document.
-          return build_adopted_identifier(data)
+          # Check for multi-level adoptions
+          identifier = build_adopted_identifier(data)
+
+          # Wrap with consolidated if supplements present
+          if supplements_data.any?
+            identifier = wrap_with_consolidated(identifier,
+                                                supplements_data)
+          end
+
+          # Wrap with ExpertCommentary if needed
+          identifier = wrap_with_expert_commentary(identifier) if data[:expert_commentary]
+
+          return identifier
         end
 
-        # Determine identifier class using the module's lookup helpers
+        # Determine identifier class using Scheme
         identifier = locate_identifier_klass(data).new
         assign_attributes(identifier, data)
 
@@ -131,11 +132,8 @@ module Pubid
                                               supplements_data)
         end
 
-        # Wrap with ExpertCommentary if needed (full "Expert Commentary" form
-        # arrives as the standalone :expert_commentary_full token)
-        if data[:expert_commentary] || data[:expert_commentary_full]
-          identifier = wrap_with_expert_commentary(identifier)
-        end
+        # Wrap with ExpertCommentary if needed
+        identifier = wrap_with_expert_commentary(identifier) if data[:expert_commentary]
 
         identifier
       end
@@ -164,7 +162,7 @@ module Pubid
 
         # Build attributes hash (conditional arguments must be handled separately)
         attrs = {
-          number: number_val,
+          number: Components::Code.new(value: number_val),
           issue_number: issue_number,
           index_format: format,
         }
@@ -181,7 +179,7 @@ module Pubid
 
         # Build attributes hash
         attrs = {
-          number: number_val,
+          number: Components::Code.new(value: number_val),
         }
         attrs[:date] = Components::Date.new(year: year_val) if year_val
 
@@ -206,9 +204,9 @@ module Pubid
 
         # Build attributes hash
         attrs = {
-          number: number_val,
+          number: Components::Code.new(value: number_val),
         }
-        attrs[:part] = part_val if part_val
+        attrs[:part] = Components::Code.new(value: part_val) if part_val
         attrs[:date] = Components::Date.new(year: year_val) if year_val
 
         Identifiers::ExplanatorySupplement.new(attrs)
@@ -248,13 +246,13 @@ module Pubid
 
         # Build attributes hash
         attrs = {
-          number: number_val,
+          number: Components::Code.new(value: number_val),
           method_code: method_code,
           method_to: method_to,
           method_and: method_and,
           is_plural: is_plural,
         }
-        attrs[:part] = part_val if part_val
+        attrs[:part] = Components::Code.new(value: part_val) if part_val
         attrs[:date] = Components::Date.new(year: year_val) if year_val
 
         Identifiers::Method.new(attrs)
@@ -280,7 +278,7 @@ module Pubid
 
         # Build attributes hash
         attrs = {
-          number: number_val,
+          number: Components::Code.new(value: number_val),
           test_series: test_series,
           test_id: test_id,
         }
@@ -313,7 +311,7 @@ module Pubid
 
         # Build attributes hash (conditional arguments must be handled separately)
         attrs = {
-          number: number_val,
+          number: Components::Code.new(value: number_val),
           section_id: section_id,
           section_format: format,
         }
@@ -343,7 +341,7 @@ module Pubid
 
         # Build attributes hash
         attrs = {
-          number: number_val,
+          number: Components::Code.new(value: number_val),
         }
         attrs[:spec_code] = Components::Code.new(value: spec_code) if spec_code
         if publisher_val
@@ -373,9 +371,9 @@ module Pubid
 
         # Build attributes hash
         attrs = {
-          number: number_val,
+          number: Components::Code.new(value: number_val),
         }
-        attrs[:part] = part_val if part_val
+        attrs[:part] = Components::Code.new(value: part_val) if part_val
         attrs[:publisher] = Components::Publisher.new(body: "DISC")
         attrs[:date] = Components::Date.new(year: year_val) if year_val
 
@@ -432,9 +430,9 @@ module Pubid
         # Build attributes hash
         attrs = {
           prefix: prefix_val,
-          number: number_val,
+          number: Components::Code.new(value: number_val),
         }
-        attrs[:part] = part_val if part_val
+        attrs[:part] = Components::Code.new(value: part_val) if part_val
         attrs[:iteration] = iteration_val if iteration_val
         attrs[:edition] = final_edition if final_edition
         attrs[:publisher] = Components::Publisher.new(body: "BS")
@@ -456,20 +454,20 @@ module Pubid
           # Build base identifier
           base_id = SingleIdentifier.new(
             publisher: Components::Publisher.new(body: "BS"),
-            number: base_number,
+            number: Components::Code.new(value: base_number),
           )
 
           # Build identifiers for each part
           id1 = SingleIdentifier.new(
             publisher: Components::Publisher.new(body: "BS"),
-            number: base_number,
-            part: part1,
+            number: Components::Code.new(value: base_number),
+            part: Components::Code.new(value: part1),
           )
 
           id2 = SingleIdentifier.new(
             publisher: Components::Publisher.new(body: "BS"),
-            number: base_number,
-            part: part2,
+            number: Components::Code.new(value: base_number),
+            part: Components::Code.new(value: part2),
           )
 
           Identifiers::BundledIdentifier.new(
@@ -636,7 +634,7 @@ module Pubid
           publisher: Components::Publisher.new(body: publisher_val),
         )
         id.prefix = prefix_val if prefix_val && !prefix_val.empty?
-        id.number = number_val if number_val
+        id.number = Components::Code.new(value: number_val) if number_val
 
         id.explicit_prefix = has_explicit_publisher || has_explicit_prefix
         id.explicit_publisher = has_explicit_publisher
@@ -646,11 +644,11 @@ module Pubid
           parts_array = parts_val[:parts]
           if parts_array.any?
             part_str = parts_array.first[:part].to_s
-            id.part = part_str
+            id.part = Components::Code.new(value: part_str)
           end
         # Handle space-separated part (direct part attribute)
         elsif space_separated_part_val
-          id.part = space_separated_part_val.to_s
+          id.part = Components::Code.new(value: space_separated_part_val.to_s)
           # Mark this part as space-separated for rendering
           id.space_separated_part = true
         end
@@ -674,7 +672,7 @@ module Pubid
         topic = @original_data[:expert_commentary_topic]&.to_s
 
         Identifiers::ExpertCommentary.new(
-          base: base_id,
+          base_identifier: base_id,
           format: format,
           topic: topic,
         )
@@ -724,7 +722,7 @@ module Pubid
                           end
 
         Identifiers::SupplementDocument.new(
-          base: base_id,
+          base_identifier: base_id,
           supplement_number: data[:supplement_number].to_s,
           supplement_year: data[:supplement_year].to_i,
           supplement_type: supplement_type,
@@ -771,7 +769,7 @@ module Pubid
         end
 
         Identifiers::AddendumDocument.new(
-          base: base_id,
+          base_identifier: base_id,
           addendum_number: data[:addendum_number].to_s,
           addendum_year: data[:addendum_year].to_i,
           addendum_type: addendum_type,
@@ -790,10 +788,8 @@ module Pubid
         corrigendum = !amd_data[:corrigendum].nil?
         parenthesized = !data[:parenthesized_amd].nil?
 
-        # NOTE `amd_data[:amendment_number]` above is a PARSE-TREE key and keeps
-        # its name; only the attribute moved to `number`.
         attrs = {
-          number: Components::Code.new(value: amendment_number),
+          amendment_number: Components::Code.new(value: amendment_number),
           corrigendum: corrigendum,
           parenthesized: parenthesized,
         }
@@ -811,10 +807,8 @@ module Pubid
         # Could also use a more sophisticated algorithm for year conversion
         full_year = year_val ? "20#{year_val}" : nil
 
-        # NOTE `data[:document_number]` above is a PARSE-TREE key and keeps its
-        # name; only the attribute moved to `number`.
         attrs = {
-          number: Components::Code.new(value: document_number),
+          document_number: document_number,
         }
         attrs[:date] = Components::Date.new(year: full_year.to_i) if full_year
 
@@ -841,7 +835,7 @@ module Pubid
         base_id = build(base_data)
 
         Identifiers::ValueAddedPublication.new(
-          base: base_id,
+          base_identifier: base_id,
           format: format,
         )
       end
@@ -886,14 +880,14 @@ module Pubid
 
           if supp[:type] == :amendment
             Identifiers::Amendment.new(
-              base: nil, # NA supplements don't wrap base
+              base_identifier: nil, # NA supplements don't wrap base
               amendment_number: supp[:number],
               amendment_year: year_val&.to_i,
               separator: supp[:separator] || "+",
             )
           else
             Identifiers::Corrigendum.new(
-              base: nil,
+              base_identifier: nil,
               corrigendum_number: supp[:number],
               corrigendum_year: year_val&.to_i,
               separator: supp[:separator] || "+",
@@ -921,7 +915,6 @@ module Pubid
             number: (supp_data[:amd_number] || supp_data[:cor_number])&.to_s,
             year: (supp_data[:amd_year] || supp_data[:cor_year])&.to_s,
             separator: separator,
-            amd_suffix_form: !(supp_data[:amd_sep_plus] || supp_data[:amd_sep_slash]),
           }
         end
       end
@@ -941,19 +934,17 @@ module Pubid
         return Identifiers::AdoptedEuropeanNorm if parsed_hash[:adopted_string]&.match?(/^EN\s+\d/)
         return Identifiers::AdoptedInternationalStandard if parsed_hash[:adopted_string]
 
-        # Use type to determine class via Pubid::Bsi.locate_stage / locate_type.
-        # Unknown abbreviations fall back to DEFAULT_TYPED_STAGE (published BS).
+        # Use type to determine class via Scheme
         type_str = parsed_hash[:type] || parsed_hash[:stage] || ""
-        typed_stage = Bsi.locate_stage(type_str.to_s.upcase) || DEFAULT_TYPED_STAGE
-        Bsi.locate_type(typed_stage.type_code) || Identifiers::BritishStandard
+        typed_stage = @scheme.locate_typed_stage_by_abbr(type_str)
+        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
       end
 
       def cast(type, value)
         case type
         when :type
-          # Lookup from register via Pubid::Bsi.locate_stage.
-          # Unknown abbreviations fall back to DEFAULT_TYPED_STAGE (published BS).
-          typed_stage = Bsi.locate_stage(value.to_s.upcase) || DEFAULT_TYPED_STAGE
+          # Lookup from register
+          typed_stage = @scheme.locate_typed_stage_by_abbr(value || "")
           {
             stage: typed_stage.to_stage,
             type: typed_stage.to_type,
@@ -973,7 +964,7 @@ module Pubid
           value&.to_s
 
         when :number
-          value.to_s
+          Components::Code.new(value: value.to_s)
 
         when :parts
           # Extract parts - handle both formats:
@@ -987,25 +978,26 @@ module Pubid
             # Check if subpart is already separated (new format from part_with_subpart rule)
             if first_part.key?(:subpart)
               {
-                part: part_str,
-                subpart: first_part[:subpart].to_s,
+                part: Components::Code.new(value: part_str),
+                subpart: Components::Code.new(value: first_part[:subpart].to_s),
               }
             else
               # Old format - split on dash to get part and subpart
               part_components = part_str.split("-")
-              result = { part: part_components.first }
+              result = { part: Components::Code.new(value: part_components.first) }
               if part_components.length > 1
-                result[:subpart] = part_components[1]
+                result[:subpart] =
+                  Components::Code.new(value: part_components[1])
               end
               result
             end
           end
 
         when :part
-          value[:part].to_s if value.is_a?(Hash)
+          Components::Code.new(value: value[:part].to_s) if value.is_a?(Hash)
 
         when :subpart
-          value.to_s
+          Components::Code.new(value: value.to_s)
 
         when :year, :date
           # Only create date if value is present
@@ -1156,10 +1148,8 @@ module Pubid
         # Extract ExComm suffix before parsing (it should be preserved in data[:expert_commentary])
         # Remove it from adopted_string so ISO/IEC parsers don't choke on it
         # Handle all three formats: "Expert Commentary", "ExComm", "ExComm (Fire)"
-        # Expert-commentary suffix matching is case-insensitive; output is always
-        # canonicalised to "Expert Commentary" / "ExComm".
-        if adopted_str.match?(/expert commentary$/i)
-          adopted_str = adopted_str.sub(/expert commentary$/i, "")
+        if adopted_str.end_with?("Expert Commentary")
+          adopted_str = adopted_str.sub(/Expert Commentary$/, "")
           data[:expert_commentary_full] = "Expert Commentary"
           data[:expert_commentary] = true unless data.key?(:expert_commentary)
           # Update @original_data so wrap_with_expert_commentary can access it
@@ -1168,8 +1158,8 @@ module Pubid
             @original_data[:expert_commentary] =
               true
           end
-        elsif adopted_str.match?(/excomm \($/i)
-          adopted_str = adopted_str.sub(/excomm \(.*\)$/i, "")
+        elsif adopted_str.end_with?("ExComm (")
+          adopted_str = adopted_str.sub(/ExComm \(.*\)$/, "")
           data[:expert_commentary_full] = "Expert Commentary"
           data[:expert_commentary] = true unless data.key?(:expert_commentary)
           @original_data[:expert_commentary_full] = "Expert Commentary"
@@ -1177,10 +1167,10 @@ module Pubid
             @original_data[:expert_commentary] =
               true
           end
-        elsif adopted_str.match?(/excomm \(/i)
+        elsif adopted_str.include?("ExComm (")
           # Extract topic from "ExComm (Fire)"
-          topic_match = adopted_str.match(/excomm\s*\(([^)]+)\)/i)
-          adopted_str = adopted_str.sub(/excomm\s*\(.*\)$/i, "")
+          topic_match = adopted_str.match(/ExComm\s*\(([^)]+)\)/)
+          adopted_str = adopted_str.sub(/ExComm\s*\(.*\)$/, "")
           data[:expert_commentary_topic] = topic_match[1] if topic_match
           data[:expert_commentary] = true unless data.key?(:expert_commentary)
           if topic_match
@@ -1191,9 +1181,9 @@ module Pubid
             @original_data[:expert_commentary] =
               true
           end
-        elsif adopted_str.match?(/excomm\s*$/i)
+        elsif adopted_str.match?(/ExComm\s*$/)
           # Abbreviated form "ExComm" at the end
-          adopted_str = adopted_str.sub(/excomm\s*$/i, "")
+          adopted_str = adopted_str.sub(/ExComm\s*$/, "")
           data[:expert_commentary] = true unless data.key?(:expert_commentary)
           unless @original_data.key?(:expert_commentary)
             @original_data[:expert_commentary] =
@@ -1259,10 +1249,9 @@ module Pubid
         # BSI uses +A1:2020 format, but ISO/IEC parsers can't handle this
         # Patterns: +A1:2020, +A11:2021, +AMD1:2001, +C1:2020
         extracted_supplements = []
-        # Match patterns like: +A1:2020, +A11:2021, +AMD1:2001, +C1:2020, +COR1:2020,
-        # and the year-less compact forms +A2 / +C1 (the ":YYYY" is optional).
+        # Match patterns like: +A1:2020, +A11:2021, +AMD1:2001, +C1:2020, +COR1:2020
         # Must be at end of string or followed by space (not colon, which is part of date)
-        adopted_str_clean = adopted_str_clean.gsub(/([+])(A(\d+)|AMD(\d+)|C(\d+)|COR(\d+))(?::(\d{4}))?(?:\s|$)/) do |_match|
+        adopted_str_clean = adopted_str_clean.gsub(/([+])(A(\d+)|AMD(\d+)|C(\d+)|COR(\d+)):(\d{4})(?:\s|$)/) do |_match|
           separator = $1 # "+" or "/"
           type_code = $2 || $3 || $4 || $5 || $6
           $2 || $3 || $4 || $5 || $6
@@ -1287,8 +1276,6 @@ module Pubid
             number: supp_number,
             year: year,
             separator: separator,
-            # compact "+A"/"/A" join form (not the trailing " AMD5" suffix form)
-            amd_suffix_form: false,
           }
 
           "" # Remove from adopted_string
@@ -1304,7 +1291,6 @@ module Pubid
             number: amd_number,
             year: nil,
             separator: nil, # No separator for AMD without year
-            amd_suffix_form: true, # trailing " AMD5" suffix form
           }
           "" # Remove from adopted_string
         end.strip
@@ -1326,15 +1312,8 @@ module Pubid
 
         adopted_id = nil
 
-        # Check for EN ISO or EN IEC patterns (triple-level).
-        # The test must be ANCHORED, because the repair below is: an unanchored
-        # match accepts "CEN ISO/TS 12180-1:2007" (the "EN ISO" is inside
-        # "CEN ISO"), but `sub(/^EN\s+/, "")` then changes nothing, so
-        # adopted_id stayed nil and the whole parse returned nil for 49
-        # "DD CEN ISO/..." identifiers in BSI's own pass fixtures. Anchored,
-        # a "CEN ..." string falls through to the CEN branch below, which is
-        # where it belongs.
-        if adopted_str_clean.match?(/\AEN\s+(ISO\/IEC|IEC|ISO)/)
+        # Check for EN ISO or EN IEC patterns (triple-level)
+        if adopted_str_clean.match?(/EN\s+(ISO\/IEC|IEC|ISO)/)
           # Parse the ISO/IEC part
           iso_iec_str = adopted_str_clean.sub(/^EN\s+/, "")
 
@@ -1377,9 +1356,6 @@ module Pubid
         # Return appropriate wrapper based on adoption type
         if adopted_id
           # If adopted_id is a CEN identifier (in Cen module), use AdoptedEuropeanNorm
-          # The Expert-commentary suffix is represented uniformly by an outer
-          # ExpertCommentary wrapper (below), never a boolean on the inner norm,
-          # so that #base_document peels cleanly to the bare standard.
           identifier = if adopted_id.class.name.start_with?("Pubid::CenCenelec::")
                          Identifiers::AdoptedEuropeanNorm.new(
                            publisher: Components::Publisher.new(body: bsi_prefix),
@@ -1387,6 +1363,10 @@ module Pubid
                            edition: final_edition&.to_s,
                            translation_lang: data[:translation_lang]&.to_s,
                            translation_upper: data[:translation_upper]&.to_s,
+                           # Pass expert_commentary data so ConsolidatedIdentifier can render it
+                           expert_commentary: data[:expert_commentary],
+                           # Pass expert_commentary_topic if present
+                           expert_commentary_topic: data[:expert_commentary_topic],
                            # Pass translation_suffix_type for rendering
                            translation_suffix_type: data[:translation_suffix_type]&.to_s,
                            # Pass reaffirmation_year for rendering
@@ -1400,6 +1380,11 @@ module Pubid
                            edition: final_edition&.to_s,
                            translation_lang: data[:translation_lang]&.to_s,
                            translation_upper: data[:translation_upper]&.to_s,
+                           # Pass expert_commentary data ONLY if no supplements
+                           # When supplements are present, ConsolidatedIdentifier will add ExComm later
+                           expert_commentary: data[:expert_commentary] && extracted_supplements.none?,
+                           # Pass expert_commentary_topic if present and no supplements
+                           expert_commentary_topic: (data[:expert_commentary_topic] if extracted_supplements.none?),
                            # Pass translation_suffix_type for rendering
                            translation_suffix_type: data[:translation_suffix_type]&.to_s,
                            # Pass reaffirmation_year for rendering
@@ -1407,13 +1392,20 @@ module Pubid
                          )
                        end
 
-          # Wrap supplements first (they render before the ExComm suffix), then
-          # wrap the whole thing in a single ExpertCommentary — same shape as the
-          # pure-BSI path, keeping #base_document uniform.
+          # NEW: Wrap with supplements if any were extracted from adopted_string
+          # This must happen BEFORE wrapping with ExpertCommentary so that supplements
+          # render before ExComm suffix
           if extracted_supplements.any?
-            identifier = wrap_with_consolidated(identifier, extracted_supplements)
-          end
-          if data[:expert_commentary] || data[:expert_commentary_full]
+            # When supplements are present, wrap with ConsolidatedIdentifier
+            # Pass expert_commentary data so ConsolidatedIdentifier can render it later
+            identifier = wrap_with_consolidated(
+              identifier,
+              extracted_supplements,
+              expert_commentary: data[:expert_commentary],
+              expert_commentary_topic: data[:expert_commentary_topic],
+            )
+          elsif data[:expert_commentary]
+            # When no supplements but ExComm present, wrap with ExpertCommentary
             identifier = wrap_with_expert_commentary(identifier)
           end
 
@@ -1421,17 +1413,17 @@ module Pubid
         end
       end
 
-      def wrap_with_consolidated(base, supplements_data,
+      def wrap_with_consolidated(base_identifier, supplements_data,
 expert_commentary: nil, expert_commentary_topic: nil)
-        # If expert_commentary data is provided, set it on the base
+        # If expert_commentary data is provided, set it on the base_identifier
         # This allows ConsolidatedIdentifier to render the ExComm suffix correctly
         if expert_commentary
-          base_attrs = base.class.attributes
+          base_attrs = base_identifier.class.attributes
           if base_attrs.key?(:expert_commentary)
-            base.expert_commentary = expert_commentary
+            base_identifier.expert_commentary = expert_commentary
           end
           if expert_commentary_topic && base_attrs.key?(:expert_commentary_topic)
-            base.expert_commentary_topic = expert_commentary_topic
+            base_identifier.expert_commentary_topic = expert_commentary_topic
           end
         end
 
@@ -1446,15 +1438,14 @@ expert_commentary: nil, expert_commentary_topic: nil)
 
           if supp[:type] == :amendment
             Identifiers::Amendment.new(
-              base: base,
+              base_identifier: base_identifier,
               amendment_number: supp[:number],
               amendment_year: year_val&.to_i,
               separator: supp[:separator] || "+",
-              amd_suffix_form: supp[:amd_suffix_form] ? true : false,
             )
           else
             Identifiers::Corrigendum.new(
-              base: base,
+              base_identifier: base_identifier,
               corrigendum_number: supp[:number],
               corrigendum_year: year_val&.to_i,
               separator: supp[:separator] || "+",
@@ -1463,7 +1454,7 @@ expert_commentary: nil, expert_commentary_topic: nil)
         end
 
         Identifiers::ConsolidatedIdentifier.new(
-          identifiers: [base] + supplement_ids,
+          identifiers: [base_identifier] + supplement_ids,
         )
       end
 
@@ -1484,9 +1475,6 @@ expert_commentary: nil, expert_commentary_topic: nil)
             number: (supp_data[:amd_number] || supp_data[:cor_number])&.to_s,
             year: (supp_data[:amd_year] || supp_data[:cor_year])&.to_s,
             separator: separator,
-            # The compact "+A"/"/A" amendment rule captures an explicit separator;
-            # the trailing " AMD5" suffix form does not.
-            amd_suffix_form: !(supp_data[:amd_sep_plus] || supp_data[:amd_sep_slash]),
           }
         end
       end