pubid 2.0.0.pre.alpha.12 → 2.0.0.pre.alpha.13

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/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/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/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/urn_generator.rb

@@ -21,15 +21,15 @@ module Pubid
           parts << identifier.flex_prefix.to_s.downcase
         end
 
-        # Fall back to the wrapped document's number. A wrapper — an adopted
-        # European norm, a bundle, a set — carries no number of its own, and
-        # `AdoptedEuropeanNorm#number` only delegates ONE level, so a
-        # "DD ENV ISO 11079:1999" (which adopts a CEN prestandard that is
-        # itself a wrapper around the ISO standard) emitted the identity-free
+        # Read identity from the wrapped document when the wrapper has none of
+        # its own. A wrapper — an adopted European norm, a bundle, a set —
+        # carries no number, part, subpart or date, so a
+        # "DD ENV ISO 11079:1999" (which adopts a CEN prestandard that is itself
+        # a wrapper around the ISO standard) emitted the identity-free
         # `urn:bsi:dd` — the same URN as every other DD adoption. `#root`
         # recurses to the origin document, and for a non-wrapper it is `self`,
         # so this changes nothing for an ordinary identifier.
-        urn_number = identifier.number || identifier.root.number
+        urn_number = identity(:number)
         if urn_number
           number = urn_number.to_s
           if identifier.iteration && !identifier.iteration.empty?
@@ -38,25 +38,22 @@ module Pubid
           parts << number
         end
 
-        if identifier.part
-          part = identifier.part.to_s
-          parts << "-#{part}"
-        end
+        urn_part = identity(:part)
+        parts << "-#{urn_part}" if urn_part
 
-        if identifier.subpart
-          subpart = identifier.subpart.to_s
-          parts << "-#{subpart}"
-        end
+        urn_subpart = identity(:subpart)
+        parts << "-#{urn_subpart}" if urn_subpart
 
         if identifier.second_number
           second = identifier.second_number.to_s
           parts << "/#{second}"
         end
 
-        if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
-          parts << identifier.date.render(context: URN_CONTEXT)
-        elsif identifier.year
-          parts << identifier.year.to_s
+        urn_date = identity(:date)
+        if urn_date.is_a?(::Pubid::Components::Date) && urn_date.present?
+          parts << urn_date.render(context: URN_CONTEXT)
+        elsif (urn_year = identity(:year))
+          parts << urn_year.to_s
         end
 
         if identifier.month
@@ -87,6 +84,19 @@ module Pubid
 
         parts.join(":")
       end
+
+      private
+
+      # An identity attribute of the identifier, or of the document it wraps.
+      # `#root` is `self` for a non-wrapper, so an ordinary identifier reads its
+      # own value twice and nothing changes.
+      def identity(attr)
+        own = identifier.public_send(attr)
+        return own if own
+
+        root = identifier.root
+        root.equal?(identifier) ? nil : root.public_send(attr)
+      end
     end
   end
 end

data/lib/pubid/builder/base.rb

@@ -195,3 +195,30 @@ module Pubid
     end
   end
 end
+
+module Pubid
+  module Builder
+    # A trailing "(all parts)" is stripped by the shared Grammar and marked
+    # on the parse tree (:all_parts). Prepended to Builder::Base so every
+    # subclass — including the ones that override #build — wraps the built
+    # identifier in its flavor's all-parts class (Pubid::AllParts).
+    module AllPartsWrap
+      # Parslet tops are a Hash or an Array of Hashes (UN's multi-token tree
+      # is an Array); the marker rides every element.
+      def all_parts_marked?(data)
+        case data
+        when Hash then data[:all_parts]
+        when Array then data.any? { |e| all_parts_marked?(e) }
+        else false
+        end
+      end
+
+      def build(data, *args, **kwargs)
+        marked = all_parts_marked?(data)
+        built = super
+        marked ? built.to_all_parts : built
+      end
+    end
+
+  end
+end

data/lib/pubid/calconnect/builder.rb

@@ -36,3 +36,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Calconnect::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/calconnect/identifier.rb

@@ -18,6 +18,10 @@ module Pubid
       attribute :number, :string
       attribute :date, ::Pubid::Components::Date
 
+      # A nil `series` means the document has none: `CC 36010` is not
+      # `CC/WD 36010`, which is a working draft of it.
+      subset_strict :series
+
       # Polymorphic type map for lutaml::Model key_value (de)serialization,
       # mapping the concrete class's polymorphic_name to its class name so a
       # stored hash rebuilds the correct identifier type via from_hash.

data/lib/pubid/ccsds/builder.rb

@@ -55,3 +55,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Ccsds::Builder.prepend(Pubid::Builder::AllPartsWrap)