pubid 2.0.0.pre.alpha.11 → 2.0.0.pre.alpha.13

data/lib/pubid/bsi/identifiers/adopted_international_standard.rb

@@ -7,8 +7,11 @@ module Pubid
       # Example: "BS ISO 8601:2019" where ISO 8601:2019 is an ISO identifier object
       # Example: "BS IEC 62600:2020" where IEC 62600:2020 is an IEC identifier object
       class AdoptedInternationalStandard < BritishStandard
-        # The adopted ISO/IEC identifier object
-        attribute :adopted, ::Pubid::Identifier, polymorphic: true
+        include RootIdentity
+
+        # The adopted ISO/IEC document, under the uniform parent accessor.
+        # `#root` and `#base_document` are inherited and walk it.
+        attribute :base, ::Pubid::Identifier, polymorphic: true
         attribute :edition, :string
         attribute :translation_lang, :string
         attribute :translation_upper, :string
@@ -26,26 +29,6 @@ module Pubid
           nil
         end
 
-        # Delegate common methods to adopted identifier
-        def number
-          adopted&.number
-        end
-
-        def year
-          adopted&.year if adopted&.methods&.include?(:year)
-        end
-
-        def date
-          adopted&.date if adopted&.methods&.include?(:date)
-        end
-
-        def parts
-          adopted&.parts if adopted&.methods&.include?(:parts)
-        end
-
-        def part
-          adopted&.part if adopted&.methods&.include?(:part)
-        end
       end
     end
   end

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

@@ -7,8 +7,22 @@ module Pubid
       # Contains a base identifier plus amendment parameters
       class Amendment < SingleIdentifier
         attribute :base, ::Pubid::Identifier, polymorphic: true
-        attribute :amendment_number, :string
-        attribute :amendment_year, :integer
+        # The amendment's ordinal lives in the `number` inherited from
+        # SingleIdentifier — already a `:string` there, which is what the
+        # ordinal is ("1", "11", "AA") — so the row reads `number:` rather than
+        # `amendment_number:`.
+        #
+        # This does NOT make the ordinal a document number: the amended
+        # standard is reached through `base`, and `#root` walks it, which is
+        # what relaton-index keys on.
+        #
+        # The year lives in the inherited `date` component, the natural home:
+        # an amendment's year belongs to the supplement, not to the standard,
+        # and `#exclude` protects it via `supplement_date_attributes` below,
+        # so `exclude(:date)` on a consolidated identifier drops only the
+        # standard's date. The flat scalar serialization rule renders a
+        # degenerate `date` as a bare `year:` key, matching CEN and every
+        # other BSI row.
         attribute :separator, :string, default: -> { "+" }
         # true for the trailing " AMD5" / " AMD AA" suffix form, false for the
         # compact "+A5" / "/A5" join form. Distinguishes the two when no year is
@@ -19,6 +33,23 @@ module Pubid
           base&.publisher
         end
 
+        # `publisher` reads through to the base, so it is never this
+        # amendment's own state. Lutaml only serializes the borrowed component
+        # when the member came from from_hash (the parse path shares the base
+        # instance, and lutaml omits the reference), which made
+        # from_hash(to_hash(id)).to_hash regrow a `publisher` key the parse
+        # path never emits. Drop it unconditionally to keep the wire symmetric.
+        def self.compact_hash(_model, hash)
+          hash.delete("publisher")
+        end
+
+        # See the comment on `date` above: protects the amendment's own date
+        # from a bare `exclude(:date)`/`exclude(:year)`, which otherwise
+        # recurses into `base` and drops the standard's date too.
+        def self.supplement_date_attributes
+          %i[date]
+        end
+
         # Base document = the standard this amendment applies to, fully peeled.
         def base_document
           base&.base_document || self
@@ -29,19 +60,12 @@ module Pubid
           base || self
         end
 
-        # Uniform supplement interface (shared with Corrigendum) so callers need
-        # not special-case the class.
+        # Names the supplement class, so callers need not special-case it. The
+        # ordinal and the year need no such method: Amendment and Corrigendum —
+        # in BSI and in CEN — all declare them as `number` and `year`.
         def supplement_type
           :amendment
         end
-
-        def supplement_number
-          amendment_number
-        end
-
-        def supplement_year
-          amendment_year
-        end
       end
     end
   end

data/lib/pubid/bsi/identifiers/british_industrial_practice.rb

@@ -6,7 +6,7 @@ module Pubid
       # British Industrial Practice (BIP)
       # Examples: "BIP 2225:2022", "BIP 0142:2014", "BIP 0009:2020"
       class BritishIndustrialPractice < SingleIdentifier
-        attribute :date, Bsi::Components::Date
+
 
         def self.type
           {

data/lib/pubid/bsi/identifiers/bundled_identifier.rb

@@ -12,6 +12,8 @@ module Pubid
       #   BS SP 13; 14; 15 and 16:1949
       #   BS 4048:Parts 1 and 2:1966
       class BundledIdentifier < SingleIdentifier
+        include RootIdentity
+
         attribute :identifiers, ::Pubid::Identifier, collection: true, 
                                                      polymorphic: true
         attribute :separators, :string, collection: true # Separators between identifiers

data/lib/pubid/bsi/identifiers/consolidated_identifier.rb

@@ -6,6 +6,8 @@ module Pubid
       # Consolidated Identifier - contains base document plus supplements
       # Example: "BS 4592-0:2006+A1:2012" = [BS 4592-0:2006, Amendment 1:2012]
       class ConsolidatedIdentifier < SingleIdentifier
+        include RootIdentity
+
         attribute :identifiers, ::Pubid::Identifier, polymorphic: true,
                                                      collection: true
 
@@ -19,11 +21,11 @@ module Pubid
           # Append supplement info to URN
           identifiers[1..].each do |id|
             if id.is_a?(Amendment)
-              urn += ":amd:#{id.amendment_number}"
-              urn += ":#{id.amendment_year}" if id.amendment_year
+              urn += ":amd:#{id.number}"
+              urn += ":#{id.year}" if id.year
             elsif id.is_a?(Corrigendum)
-              urn += ":cor:#{id.corrigendum_number}"
-              urn += ":#{id.corrigendum_year}" if id.corrigendum_year
+              urn += ":cor:#{id.number}"
+              urn += ":#{id.year}" if id.year
             end
           end
           urn
@@ -34,30 +36,25 @@ module Pubid
           identifiers&.first&.publisher
         end
 
-        def number
-          identifiers&.first&.number
-        end
-
-        def year
-          base = identifiers&.first
-          base.year if base&.class&.attributes&.key?(:year)
-        end
-
-        def date
-          base = identifiers&.first
-          base.date if base&.class&.attributes&.key?(:date)
-        end
-
-        def parts
-          base = identifiers&.first
-          base.parts if base&.class&.attributes&.key?(:parts)
-        end
-
-        def part
-          base = identifiers&.first
-          base.part if base&.class&.attributes&.key?(:part)
+        # See Identifiers::Amendment.compact_hash: the publisher is derived
+        # from the first member and must stay off the wrapper's own wire entry,
+        # or from_hash round-trips regrow it.
+        def self.compact_hash(_model, hash)
+          hash.delete("publisher")
         end
 
+        # `number`, `part`, `parts`, `date` and `year` are deliberately NOT
+        # delegated. They used to read `identifiers.first`, one level only, so
+        # they answered with the member's value when that member was a plain
+        # standard and with nil when it was itself a wrapper (an adoption) —
+        # the same accessor reporting two different things. They also shadowed
+        # real lutaml attributes, and the `date` one handed lutaml a foreign
+        # `Pubid::Components::Date` where BSI declares its own subclass, which
+        # is what made `to_hash` raise.
+        #
+        # A BSI wrapper owns no identity: `#root` carries it, recursively and
+        # for every layer. See `Identifiers::RootIdentity` and
+        # lib/pubid/bsi/CLAUDE.md.
         def type
           base = identifiers&.first
           base.type if base&.class&.attributes&.key?(:type)

data/lib/pubid/bsi/identifiers/corrigendum.rb

@@ -7,14 +7,38 @@ module Pubid
       # Contains a base identifier plus corrigendum parameters
       class Corrigendum < SingleIdentifier
         attribute :base, ::Pubid::Identifier, polymorphic: true
-        attribute :corrigendum_number, :string
-        attribute :corrigendum_year, :integer
+        # The ordinal lives in `number` (inherited, already a `:string`), and
+        # the year in the inherited `date` component, exactly as on Amendment
+        # — see that class for why `date` is now safe to use: `#exclude`
+        # protects it via `supplement_date_attributes` below, so
+        # `exclude(:date)` drops only the standard's date. The flat scalar
+        # serialization rule renders a degenerate `date` as a bare `year:`
+        # key, so relaton still compares a plain String across supplement
+        # classes and flavors.
+        #
+        # The year is nil for a year-less corrigendum (`BS 1234:2015+C1`),
+        # which parses; `number` is in practice always set, because the grammar
+        # requires a digit after the `C` — the unnumbered `+C:2016` form that
+        # CEN spells `AC` does not parse in BSI at all.
         attribute :separator, :string, default: -> { "+" }
 
         def publisher
           base&.publisher
         end
 
+        # See Amendment.compact_hash: the publisher is borrowed from the base
+        # and must never appear on the supplement's own wire entry.
+        def self.compact_hash(_model, hash)
+          hash.delete("publisher")
+        end
+
+        # See the comment on `date` above: protects the corrigendum's own
+        # date from a bare `exclude(:date)`/`exclude(:year)`, which otherwise
+        # recurses into `base` and drops the standard's date too.
+        def self.supplement_date_attributes
+          %i[date]
+        end
+
         # Base document = the standard this corrigendum applies to, fully peeled.
         def base_document
           base&.base_document || self
@@ -25,19 +49,12 @@ module Pubid
           base || self
         end
 
-        # Uniform supplement interface (shared with Amendment) so callers need
-        # not special-case the class.
+        # Names the supplement class, so callers need not special-case it. The
+        # ordinal and the year need no such method: Amendment and Corrigendum —
+        # in BSI and in CEN — all declare them as `number` and `year`.
         def supplement_type
           :corrigendum
         end
-
-        def supplement_number
-          corrigendum_number
-        end
-
-        def supplement_year
-          corrigendum_year
-        end
       end
     end
   end

data/lib/pubid/bsi/identifiers/expert_commentary.rb

@@ -10,6 +10,8 @@ module Pubid
       # 2. "ExComm" (abbreviated form)
       # 3. "ExComm (Fire)" (with optional topic suffix)
       class ExpertCommentary < SingleIdentifier
+        include RootIdentity
+
         attribute :base, ::Pubid::Identifier, polymorphic: true
         attribute :format, :string # "full", "abbr", "abbr_with_topic"
         attribute :topic, :string # e.g., "Fire"
@@ -18,13 +20,10 @@ module Pubid
           base&.publisher
         end
 
-        def number
-          base&.number
-        end
-
-        def year
-          base&.year
-        end
+        # `number` and `year` are deliberately NOT delegated — a BSI wrapper
+        # owns no identity, and a one-level delegation answered with nil
+        # whenever `base` was itself a wrapper. `#root` carries identity for
+        # every layer. See `Identifiers::RootIdentity` and lib/pubid/bsi/CLAUDE.md.
 
         # Base document = the commented standard, fully peeled.
         def base_document

data/lib/pubid/bsi/identifiers/handbook.rb

@@ -6,7 +6,7 @@ module Pubid
       # BSI Handbook
       # Examples: "Handbook 17:1963", "HB 10146:1998"
       class Handbook < SingleIdentifier
-        attribute :date, Bsi::Components::Date
+
         attribute :original_abbr, :string # Preserve "Handbook" or "HB"
 
         def self.type

data/lib/pubid/bsi/identifiers/national_annex.rb

@@ -6,8 +6,24 @@ module Pubid
       # National Annex (NA) identifier
       # Can have own supplements: "NA+A1:2012 to BASE"
       class NationalAnnex < SingleIdentifier
-        attribute :na_supplements, ::Pubid::Identifier, polymorphic: true, collection: true # Supplements on the NA itself
-        attribute :base_doc, ::Pubid::Identifier, polymorphic: true # The identifier after "to"
+        include RootIdentity
+
+        # Supplements on the NA itself. `initialize_empty: true` because the
+        # builder always passes an array (empty when the grammar matched no
+        # supplement) while `from_hash` never sets the attribute at all — the
+        # serialized hash omits an empty collection — so a parsed NA held `[]`
+        # and a deserialized one `nil`, and the two were not `==`. `#matches?`
+        # is `exclude(*ignore) == other.exclude(*ignore)`, so every index lookup
+        # of a supplement-less NA silently returned nothing. The `collection:
+        # true` lesson in CLAUDE.md, and the same one-line remedy.
+        attribute :na_supplements, ::Pubid::Identifier, polymorphic: true,
+                                                        collection: true,
+                                                        initialize_empty: true
+        # The identifier after "to", under the uniform parent accessor. `#root`
+        # and `#base_document` are inherited and walk it, so the delegating
+        # readers this class used to carry are gone — they shadowed real lutaml
+        # accessors and reached only one level down.
+        attribute :base, ::Pubid::Identifier, polymorphic: true
 
         TYPED_STAGES = [
           Pubid::Components::TypedStage.new(
@@ -24,24 +40,6 @@ module Pubid
           { key: :na,
             web: :national_annex, title: "National Annex", short: "NA" }
         end
-
-        # Delegation methods to access wrapped base_doc attributes
-        def number
-          base_doc&.number || super
-        end
-
-        def date
-          base_doc&.date || super
-        end
-
-        def part
-          base_doc&.part || super
-        end
-
-        def subpart
-          base_doc&.subpart || super
-        end
-
       end
     end
   end

data/lib/pubid/bsi/identifiers/practice_guide.rb

@@ -6,7 +6,7 @@ module Pubid
       # BSI Practice Guide (PP - Published Practice)
       # Examples: "PP 888:1982", "PP 7307:1986", "PP 7722:2006"
       class PracticeGuide < SingleIdentifier
-        attribute :date, Bsi::Components::Date
+
 
         def self.type
           {

data/lib/pubid/bsi/identifiers/root_identity.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    module Identifiers
+      # MR-slug hooks for a BSI wrapper that carries no identity of its own.
+      #
+      # The base `mr_number_with_part` and `mr_year` read the receiver's own
+      # `number`, `part`, `subpart` and `date`. A wrapper — an adoption, a
+      # national annex, a consolidated edition, an Expert-commentary volume —
+      # leaves all four nil and keeps the identity on the document it wraps, so
+      # those hooks produced a slug with no number at all: 158 BSI identifiers
+      # collapsed onto the bare `bs`, and `to_slug` is an output FILENAME.
+      #
+      # `#root` and not `base`: a "DD ENV ISO 11079:1999" adopts a CEN
+      # EuropeanPrestandard, which is itself a wrapper around the ISO standard,
+      # so one level down is not far enough. `#root` recurses, and for a
+      # non-wrapper it is `self` — hence the `equal?` guard, which sends an
+      # ordinary identifier to the base hooks unchanged.
+      module RootIdentity
+        def mr_number_with_part
+          root.equal?(self) ? super : root.mr_number_with_part
+        end
+
+        def mr_year
+          root.equal?(self) ? super : root.mr_year
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bsi/identifiers/set.rb

@@ -13,6 +13,8 @@ module Pubid
       #   BS ISO 20400 + BS ISO 44001+BS ISO 44002
       #   BS ISO 9001+BS ISO 14001
       class Set < SingleIdentifier
+        include RootIdentity
+
         attribute :identifiers, ::Pubid::Identifier, collection: true, 
                                                      polymorphic: true
         attribute :separators, :string, collection: true # Should all be " + "

data/lib/pubid/bsi/identifiers/supplement_document.rb

@@ -9,6 +9,8 @@ module Pubid
       # Forward: "BS 1000:Supplement No. 1:1972", "BS 1722-1 Supplement No. 1:1974"
       # Reverse: "Supplement No. 1 (1970) to BS 1831:1969"
       class SupplementDocument < SingleIdentifier
+        include RootIdentity
+
         attribute :base, ::Pubid::Identifier, polymorphic: true
         attribute :supplement_number, :string
         attribute :supplement_year, :integer

data/lib/pubid/bsi/identifiers.rb

@@ -35,6 +35,7 @@ module Pubid
       autoload :PublishedDocument, "#{__dir__}/identifiers/published_document"
       autoload :PubliclyAvailableSpecification,
                "#{__dir__}/identifiers/publicly_available_specification"
+      autoload :RootIdentity, "#{__dir__}/identifiers/root_identity"
       autoload :Section, "#{__dir__}/identifiers/section"
       autoload :Set, "#{__dir__}/identifiers/set"
       autoload :StandaloneAmendment,

data/lib/pubid/bsi/parser.rb

@@ -412,49 +412,49 @@ module Pubid
       rule(:addendum_document) do
         # With multi-letter flex type prefix (CECC, E9111, etc.)
         (bs.as(:publisher) >> space >> multi_letter_prefix.as(:flex_prefix) >> space >> number.as(:number) >> iteration.as(:iteration) >> parts.as(:parts) >>
-         (colon | space).as(:add_sep) >> str("Addendum") >> space >> str("No.").as(:add_no_prefix) >> space >>
+         (colon | space).as(:add_sep) >> str("Addendum") >> space.repeat(1) >> str("No.").as(:add_no_prefix) >> space.repeat(1) >>
          digits.as(:addendum_number) >> colon >> digit.repeat(4,
                                                               4).as(:addendum_year)
         ).as(:addendum_document) |
           (bs.as(:publisher) >> space >> multi_letter_prefix.as(:flex_prefix) >> space >> number.as(:number) >> iteration.as(:iteration) >> parts.as(:parts) >>
-           (colon | space).as(:add_sep) >> str("Addendum") >> space >>
+           (colon | space).as(:add_sep) >> str("Addendum") >> space.repeat(1) >>
            digits.as(:addendum_number) >> colon >> digit.repeat(4,
                                                                 4).as(:addendum_year)
           ).as(:addendum_document) |
           # With single-letter flex type prefix (M, etc.)
           (bs.as(:publisher) >> space >> single_letter_prefix.as(:flex_prefix) >> space >> number.as(:number) >> iteration.as(:iteration) >> parts.as(:parts) >>
-           (colon | space).as(:add_sep) >> str("Addendum") >> space >> str("No.").as(:add_no_prefix) >> space >>
+           (colon | space).as(:add_sep) >> str("Addendum") >> space.repeat(1) >> str("No.").as(:add_no_prefix) >> space.repeat(1) >>
            digits.as(:addendum_number) >> colon >> digit.repeat(4,
                                                                 4).as(:addendum_year)
           ).as(:addendum_document) |
           (bs.as(:publisher) >> space >> single_letter_prefix.as(:flex_prefix) >> space >> number.as(:number) >> iteration.as(:iteration) >> parts.as(:parts) >>
-           (colon | space).as(:add_sep) >> str("Addendum") >> space >>
+           (colon | space).as(:add_sep) >> str("Addendum") >> space.repeat(1) >>
            digits.as(:addendum_number) >> colon >> digit.repeat(4,
                                                                 4).as(:addendum_year)
           ).as(:addendum_document) |
           # With year before Addendum and SPACE separator: "BS NUMBER:YEAR Addendum No. N:YEAR"
           (bs.as(:publisher) >> space >> number.as(:number) >> iteration.as(:iteration) >> parts.as(:parts) >>
            colon >> digit.repeat(4,
-                                 4).as(:base_year) >> space.as(:add_sep) >> str("Addendum") >> space >> str("No.").as(:add_no_prefix) >> space >>
+                                 4).as(:base_year) >> space.as(:add_sep) >> str("Addendum") >> space.repeat(1) >> str("No.").as(:add_no_prefix) >> space.repeat(1) >>
            digits.as(:addendum_number) >> colon >> digit.repeat(4,
                                                                 4).as(:addendum_year)
           ).as(:addendum_document) |
           # With year before Addendum and COLON separator: "BS NUMBER:YEAR:Addendum No. N:YEAR"
           (bs.as(:publisher) >> space >> number.as(:number) >> iteration.as(:iteration) >> parts.as(:parts) >>
            colon >> digit.repeat(4,
-                                 4).as(:base_year) >> colon.as(:add_sep) >> str("Addendum") >> space >> str("No.").as(:add_no_prefix) >> space >>
+                                 4).as(:base_year) >> colon.as(:add_sep) >> str("Addendum") >> space.repeat(1) >> str("No.").as(:add_no_prefix) >> space.repeat(1) >>
            digits.as(:addendum_number) >> colon >> digit.repeat(4,
                                                                 4).as(:addendum_year)
           ).as(:addendum_document) |
           # Without flex type prefix - with "No." prefix
           (bs.as(:publisher) >> space >> number.as(:number) >> iteration.as(:iteration) >> parts.as(:parts) >>
-           (colon | space).as(:add_sep) >> str("Addendum") >> space >> str("No.").as(:add_no_prefix) >> space >>
+           (colon | space).as(:add_sep) >> str("Addendum") >> space.repeat(1) >> str("No.").as(:add_no_prefix) >> space.repeat(1) >>
            digits.as(:addendum_number) >> colon >> digit.repeat(4,
                                                                 4).as(:addendum_year)
           ).as(:addendum_document) |
           # Without "No." prefix
           (bs.as(:publisher) >> space >> number.as(:number) >> iteration.as(:iteration) >> parts.as(:parts) >>
-           (colon | space).as(:add_sep) >> str("Addendum") >> space >>
+           (colon | space).as(:add_sep) >> str("Addendum") >> space.repeat(1) >>
            digits.as(:addendum_number) >> colon >> digit.repeat(4,
                                                                 4).as(:addendum_year)
           ).as(:addendum_document)

data/lib/pubid/bsi/renderer.rb

@@ -212,7 +212,7 @@ module Pubid
                  end
 
         result = prefix
-        result += " #{id.adopted}" if id.adopted
+        result += " #{id.base}" if id.base
         result += " ED#{id.edition}" if id.edition
 
         result += " (R#{id.reaffirmation_year})" if id.reaffirmation_year
@@ -237,7 +237,7 @@ module Pubid
                  end
 
         result = prefix
-        result += " #{id.adopted}" if id.adopted
+        result += " #{id.base}" if id.base
         result += " ED#{id.edition}" if id.edition
 
         result += " (R#{id.reaffirmation_year})" if id.reaffirmation_year
@@ -303,16 +303,16 @@ module Pubid
 
         if id.amd_suffix_form
           # Trailing " AMD5" / " AMD AA" suffix form
-          suffix = if id.amendment_number&.match?(/^[A-Z]+$/)
-                     " AMD #{id.amendment_number}"
+          suffix = if id.number&.match?(/^[A-Z]+$/)
+                     " AMD #{id.number}"
                    else
-                     " AMD#{id.amendment_number}"
+                     " AMD#{id.number}"
                    end
           base.empty? ? suffix.lstrip : "#{base}#{suffix}"
         else
           # Compact "+A5" / "/A5" join form, with an optional ":year"
-          compact = "#{id.separator}A#{id.amendment_number}"
-          compact += ":#{id.amendment_year}" if id.amendment_year
+          compact = "#{id.separator}A#{id.number}"
+          compact += ":#{id.year}" if id.year
           "#{base}#{compact}"
         end
       end
@@ -422,21 +422,21 @@ module Pubid
         id.identifiers[1..].each do |idd|
           if idd.is_a?(Identifiers::Amendment)
             if idd.amd_suffix_form
-              result += if idd.amendment_number&.match?(/^[A-Z]+$/)
-                          " AMD #{idd.amendment_number}"
+              result += if idd.number&.match?(/^[A-Z]+$/)
+                          " AMD #{idd.number}"
                         else
-                          " AMD#{idd.amendment_number}"
+                          " AMD#{idd.number}"
                         end
             else
               sep = idd.separator || "+"
-              result += "#{sep}A#{idd.amendment_number}"
-              result += ":#{idd.amendment_year}" if idd.amendment_year
+              result += "#{sep}A#{idd.number}"
+              result += ":#{idd.year}" if idd.year
             end
           elsif idd.is_a?(Identifiers::Corrigendum)
             sep = idd.separator || "+"
             result += "#{sep}C"
-            result += idd.corrigendum_number.to_s if idd.corrigendum_number
-            result += ":#{idd.corrigendum_year}" if idd.corrigendum_year
+            result += idd.number.to_s if idd.number
+            result += ":#{idd.year}" if idd.year
           else
             result += idd.to_s
           end
@@ -485,8 +485,8 @@ module Pubid
       def render_corrigendum(id)
         result = id.base ? id.base.to_s : ""
         result += "#{id.separator}C"
-        result += id.corrigendum_number.to_s if id.corrigendum_number
-        result += ":#{id.corrigendum_year}" if id.corrigendum_year
+        result += id.number.to_s if id.number
+        result += ":#{id.year}" if id.year
         result
       end
 
@@ -753,17 +753,17 @@ module Pubid
         if id.na_supplements&.any?
           id.na_supplements.each do |supp|
             if supp.is_a?(Identifiers::Amendment)
-              result += "+A#{supp.amendment_number}:#{supp.amendment_year}"
+              result += "+A#{supp.number}:#{supp.year}"
             elsif supp.is_a?(Identifiers::Corrigendum)
-              result += "+C#{supp.corrigendum_number}:#{supp.corrigendum_year}"
+              result += "+C#{supp.number}:#{supp.year}"
             end
           end
         end
 
         result += " to "
 
-        result += if id.base_doc
-                    id.base_doc.to_s
+        result += if id.base
+                    id.base.to_s
                   else
                     render_single_identifier(id)
                   end

data/lib/pubid/bsi/single_identifier.rb

@@ -50,9 +50,18 @@ module Pubid
       attribute :part, :string
       attribute :subpart, :string
       attribute :second_number, Bsi::Components::Code # For collections like PAS 2035/2030
-      attribute :date, Bsi::Components::Date
+      # The shared component, not Bsi::Components::Date: the adoption wrappers
+      # (AdoptedEuropeanNorm, AdoptedInternationalStandard) delegate `date` to
+      # the foreign identifier they wrap, whose date is a plain
+      # ::Pubid::Components::Date — the empty BSI subclass rejected it and
+      # to_hash/from_hash raised on every "BS EN …"/"BS ISO …" (pubid#379,
+      # the same shape as the bsi-set-cross-flavor-type fix).
+      attribute :date, ::Pubid::Components::Date
       attribute :stage, Pubid::Components::Stage
-      attribute :type, Bsi::Components::Type
+      # Shared Type too: the leaf builders reach for ::Pubid::Components::Type
+      # (e.g. a default materialized from self.type), which the empty BSI
+      # subclass rejected — "BIP 2225:2022" et al. failed to_hash on `type`.
+      attribute :type, ::Pubid::Components::Type
       attribute :typed_stage, Pubid::Components::TypedStage
       attribute :edition, :string
       attribute :month, :integer