pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.12

data/lib/pubid/oasis/identifier.rb

@@ -16,15 +16,27 @@ module Pubid
       # The exact slug printed after "OASIS " — always set. Drives `to_s`, so
       # the printed form round-trips verbatim regardless of decomposition.
       attribute :original, :string
-      # Best-effort decomposition (any may be nil). `spec`/`label` are plain
+      # Best-effort decomposition (any may be nil). `number`/`label` are plain
       # slug fragments; `version`/`stage`/`part` carry the recognized fragment
       # verbatim (e.g. "3.0", "v1.2.1", "PS01", "Errata01", "Pt8", "Part1").
-      attribute :spec, :string
+      #
+      # `number` holds the specification name ("OSLC-CM", "STIX", "amqp-core").
+      # It is the key relaton-index sorts and binary-searches on
+      # (`id.root.number.to_s`), and it deliberately CLUSTERS: every version,
+      # stage and part of one specification shares it, the same shape as an
+      # IETF draft slug or an IANA registry slug.
+      #
+      # `number`/`stage`/`part` intentionally override the inherited
+      # Components::Code / Components::Stage attributes with plain strings (the
+      # mechanism JIS uses for `number` and W3C for `date`): OASIS names,
+      # stages and parts are opaque tokens that must round-trip exactly and are
+      # never re-parsed as structured parts. Redefining an inherited attribute
+      # is only deterministic under multi-flavor load because this class body
+      # lives in ONE file and is never reopened, so lutaml has finished
+      # building the table before `Identifiers::Standard` snapshots it — DO NOT
+      # split this class across two files.
+      attribute :number, :string
       attribute :version, :string
-      # `stage`/`part` intentionally override the inherited Components::Stage /
-      # Components::Code attributes with plain strings (same mechanism JIS uses
-      # for `number`, W3C for `date`): OASIS stages/parts are opaque tokens that
-      # must round-trip exactly and are never re-parsed as structured parts.
       attribute :stage, :string
       attribute :part, :string
       attribute :label, :string
@@ -39,7 +51,7 @@ module Pubid
       key_value do
         map "_type", to: :_type, polymorphic_map: OASIS_TYPE_MAP
         map "original", to: :original
-        map "spec", to: :spec
+        map "number", to: :number
         map "version", to: :version
         map "stage", to: :stage
         map "part", to: :part
@@ -58,24 +70,90 @@ module Pubid
         render(format: :human, **opts)
       end
 
+      # The decomposition fields. Excluding any of them must also clear
+      # `original`, which still spells the excluded value out verbatim.
+      DECOMPOSITION_KEYS = %i[number version stage part label].freeze
+
+      # Widen a partial reference. `#matches?` is
+      # `exclude(*ignore) == other.exclude(*ignore)`, and `original` carries
+      # every component verbatim, so without this a bare "OASIS WSDM" could
+      # never match "OASIS WSDM-v1.1" however much the caller ignored.
+      #
+      # `original` is cleared ONLY when the exclusion touches the
+      # decomposition — the "reset the whole cluster" rule CSA applies to its
+      # year-format siblings. A plain `==` still compares `original`, so two
+      # slugs that decompose alike but print differently stay distinct: the
+      # decomposition loses fragment order and drops repeated fragments, so it
+      # is not by itself an identity.
+      def exclude(*args)
+        result = super
+        result.original = nil if args.intersect?(DECOMPOSITION_KEYS)
+        result
+      end
+
+      # MR string hooks. `to_slug` delegates to `to_mr_string` and consumers
+      # use it as an output FILENAME, so the slug must be unique per document.
+      #
+      # The publisher lives in the PUBLISHER constant rather than the inherited
+      # lutaml attribute, so the base `mr_publisher` returns nil (the BIPM and
+      # IANA case) and is supplied here.
+      def mr_publisher
+        PUBLISHER.downcase
+      end
+
+      # The whole verbatim slug, not the decomposed fields: decomposition loses
+      # fragment order and drops repeated fragments, so "x-1.0-os-Pt1" and
+      # "x-1.0-Pt1-os" would assemble to one slug. `original` cannot collide.
+      def mr_number_with_part
+        mr_sanitize(original)
+      end
+
       # from_hash is the shared polymorphic dispatch on Pubid::Identifier;
       # OASIS_TYPE_MAP remains as the key_value polymorphic_map.
 
       # Parse an OASIS identifier string into an identifier object
       # @param identifier [String] The OASIS identifier string to parse
       # @return [Identifier] The Standard identifier object
-      # @raise [RuntimeError] If parsing fails
+      # @raise [Pubid::Errors::ParseError] If parsing fails
       def self.parse(identifier)
         # Reject pathological inputs before they reach the parser
         # (CodeQL rb/polynomial-redos barrier — inline .length by design).
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
         if identifier.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         parsed = Parser.parse(identifier)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse OASIS identifier '#{identifier}': #{e.message}"
+      end
+
+      private
+
+      # Filter by CHARSET, not by an enumerated escape list, so a field added
+      # later cannot leak an unsafe character (the BIPM `mr_slug` precedent).
+      # Three characters need it today: the "." in every version —
+      # Renderers::MrString joins SEGMENTS with ".", so a dot inside one breaks
+      # the documented segment structure — plus the space and "]" of a few
+      # malformed records.
+      #
+      # A RUN of non-alphanumerics collapses to one "-", which is why "-" is
+      # outside the kept set (BIPM's form, not ETSI's): "v3.0]-PS01" would
+      # otherwise print a bare "--".
+      #
+      # Caveat, the same one BIPM records: "-" is both the intra-slug join and
+      # the substitute, so two slugs differing ONLY in which non-slug character
+      # they use collapse onto one MR string. The corpus has exactly one such
+      # pair, the malformed "OpenC2-MQTT-v1.0] -CS01" spelled once with a
+      # normal space and once with a non-breaking one — two spellings of one
+      # document. Every genuinely distinct identifier keeps its own slug.
+      def mr_sanitize(value)
+        slug = value.to_s.downcase.gsub(/[^a-z0-9]+/, "-")
+          .gsub(/\A-+|-+\z/, "")
+        slug.empty? ? nil : slug
       end
     end
   end

data/lib/pubid/oasis/parser.rb

@@ -16,7 +16,7 @@ module Pubid
     # Builder with order-independent fragment classification. Keeping
     # decomposition out of the PEG avoids brittle backtracking and guarantees a
     # lossless round-trip.
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:prefix) { str("OASIS") >> str(" ") }
 
       # The whole slug, captured verbatim (any character, incl. spaces / "]").

data/lib/pubid/oasis.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Oasis
     extend Pubid::PrefixesSupport
@@ -21,8 +22,13 @@ module Pubid
     def self.parse(identifier)
       # Reject pathological inputs before they reach the parser
       # (CodeQL rb/polynomial-redos barrier — inline .length by design).
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
       if identifier.length > Pubid::MAX_INPUT_LENGTH
-        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
       Identifier.parse(identifier)

data/lib/pubid/ogc/identifier.rb

@@ -61,16 +61,20 @@ module Pubid
       # Parse an OGC identifier string into an identifier object.
       # @param identifier [String] The OGC identifier string to parse
       # @return [Identifier] The document identifier object
-      # @raise [ArgumentError] If the input exceeds the maximum length
-      # @raise [RuntimeError] If parsing fails
+      # @raise [Pubid::Errors::InvalidInputError]
+      #   If the input exceeds the maximum length
+      # @raise [Pubid::Errors::ParseError] If parsing fails
       def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
         if identifier.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         Builder.build(Parser.parse(identifier))
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse OGC identifier '#{identifier}': #{e.message}"
       end
     end
   end

data/lib/pubid/ogc/parser.rb

@@ -12,7 +12,7 @@ module Pubid
     # leniency, though the canonical printed form omits it.
     #
     # Examples: "25-023", "24-032r1", "01-009a", "04-095c1", "OGC 24-032r1".
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:space) { match["\\s"].repeat(1) }
       rule(:digits) { match["0-9"].repeat(1) }
 

data/lib/pubid/ogc.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Ogc
     extend Pubid::PrefixesSupport

data/lib/pubid/oiml/builder.rb

@@ -152,7 +152,11 @@ module Pubid
             code_attrs[:suffix] = parsed_hash[:code_suffix].to_s
             code_attrs[:space_suffix] = true if parsed_hash.key?(:space_suffix)
           end
-          identifier.code = Components::Code.new(**code_attrs)
+          # The code fields are flat index columns on the leaf (see
+          # Identifiers::CodeNumber) — `number` is what relaton-index keys on —
+          # so they are assigned individually rather than as a Code object.
+          # Bulletin has no code columns and never reaches this branch.
+          code_attrs.each { |name, value| identifier.public_send(:"#{name}=", value) }
         end
 
         # Handle other attributes
@@ -224,13 +228,13 @@ module Pubid
           article_id = parsed_hash[:article_id].to_s
           identifier.date ||= Pubid::Components::Date.new
           identifier.date.year = article_id[0, 4]
-          identifier.issue = article_id[4, 2]
+          identifier.number = article_id[4, 2]
           identifier.sequence = article_id[6, 2]
           warn_on_volume_mismatch(identifier, parsed_hash[:volume_roman])
           return
         end
 
-        identifier.issue = parsed_hash[:issue].to_s if parsed_hash[:issue]
+        identifier.number = parsed_hash[:issue].to_s if parsed_hash[:issue]
         identifier.sequence = parsed_hash[:sequence].to_s if parsed_hash[:sequence]
       end
 

data/lib/pubid/oiml/identifiers/basic_publication.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class BasicPublication < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "B"
         end

data/lib/pubid/oiml/identifiers/bulletin.rb

@@ -33,18 +33,48 @@ module Pubid
         # carried in the structured form and the roman volume in citations.
         BASE_YEAR_OFFSET = 1959
 
-        # Zero-padded issue number within the year ("01".."04", plus "07"/"10"
-        # for the online-bulletin series). Always 2 digits.
-        attribute :issue, :string
+        # The issue: the zero-padded number within the volume ("01".."04",
+        # plus "07"/"10" for the online-bulletin series). Always 2 digits. The
+        # year is the volume and the issue is the number, as in the citation
+        # form "LXVII(2)".
+        #
+        # Declared as `number`, so it is the relaton index key
+        # (`id.root.number.to_s`) and every index row with an issue shows a
+        # `number`. The key puts the same issue number of all volumes in one
+        # bucket; the MR slug keeps each article distinct.
+        #
+        # Declared on this LEAF, which has no subclasses. It redefines the
+        # `Components::Code number` of ::Pubid::Identifier as a :string, and a
+        # redefinition on a class that other classes inherit is the
+        # multi-flavor determinism landmine (see Identifiers::CodeNumber).
+        #
+        # nil for a volume ("OIML Bulletin 1960") and for the bare periodical
+        # reference "OIML Bulletin", which name no issue.
+        attribute :number, :string
         # Zero-padded sequence within the issue ("00" = editorial, "01"+ for
         # articles). Always 2 digits.
         attribute :sequence, :string
 
         key_value do
-          map "issue", to: :issue
+          map "number", to: :number
           map "sequence", to: :sequence
         end
 
+        # The inherited hook reads through `code`, which Bulletin does not
+        # have, so it would return nil and collapse every article of a year
+        # onto `oiml.bulletin.<year>`; `to_slug` is an output FILENAME, so that
+        # is an overwrite. Emit the rest of the locator instead.
+        #
+        # The year is deliberately NOT included: Renderers::MrString already
+        # gives it its own segment (`mr_year`), so repeating it here would
+        # render `oiml.bulletin.1960-03-01.1960`.
+        def mr_number_with_part
+          segments = [number, sequence].compact
+          return nil if segments.empty?
+
+          segments.join("-")
+        end
+
         def type_string
           "Bulletin"
         end
@@ -60,18 +90,18 @@ module Pubid
         # Volume as a roman-numeral string ("LXVII"), derived from the year.
         # nil when the year is absent.
         def volume_roman
-          number = volume_arabic&.to_i
-          return nil unless number&.positive?
+          volume = volume_arabic&.to_i
+          return nil unless volume&.positive?
 
-          self.class.to_roman(number)
+          self.class.to_roman(volume)
         end
 
         # 8-digit oiml.org article id ("20260211"). Composed by concatenating
-        # year + issue + sequence. nil unless all three are present.
+        # year + issue (number) + sequence. nil unless all three are present.
         def article_id
-          return nil unless date&.year && issue && sequence
+          return nil unless date&.year && number && sequence
 
-          "#{date.year}#{issue}#{sequence}"
+          "#{date.year}#{number}#{sequence}"
         end
 
         class << self

data/lib/pubid/oiml/identifiers/code_number.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      # Installs the flat, index-friendly code columns and their serialization
+      # on the seven concrete OIML document leaves (Recommendation, Document,
+      # Vocabulary, Guide, BasicPublication, ExpertReport, SeminarReport).
+      #
+      # Why the leaves and not Pubid::Oiml::SingleIdentifier, which they all
+      # inherit from: `number` redefines the parent ::Pubid::Identifier's
+      # `attribute :number, Components::Code` as a plain :string (and `part` /
+      # `subpart` likewise). Declaring that on a class the concrete types
+      # INHERIT from resolves against the parent definition nondeterministically
+      # under multi-flavor load — it passes an OIML-only run and can flip
+      # `root.number` to "" under the full suite (the IEEE lesson; see
+      # lib/pubid/ieee/identifiers/code_number.rb and CLAUDE.md). Declaring on
+      # each leaf removes the ambiguity at the point of use.
+      #
+      # This matters because relaton-index sorts and bsearches every row on
+      # `id.root.number.to_s`. OIML kept the code in an Oiml::Components::Code
+      # under a `code` attribute and never set `number`, so all 12,226 lines of
+      # the published relaton-data-oiml index-v2 keyed "".
+      #
+      # The serialized hash ALREADY had these as bare top-level scalars — the
+      # old converters merely read them through `code` — so the wire format is
+      # byte-identical and that index needs no regeneration.
+      #
+      # Bulletin deliberately does NOT include this module. It carries no code
+      # at all (its locator is the year/issue/sequence tuple), so it would only
+      # gain permanently-nil part/subpart/suffix columns. It declares its own
+      # `number` (the issue) instead; see bulletin.rb.
+      module CodeNumber
+        def self.included(base)
+          install_attributes(base)
+          install_mappings(base)
+        end
+
+        def self.install_attributes(base)
+          # Bare document number ("144"), the relaton index key. The part is a
+          # sibling column, never folded in, so every part of a document shares
+          # one bucket and a part-less reference finds them all.
+          base.attribute :number, :string
+          base.attribute :part, :string
+          base.attribute :subpart, :string
+          # Free-form trailing suffix glued to the code, e.g. "sup", "A",
+          # "erratum", "GUM 1", "ISO3930". Preserved verbatim for round-trip.
+          base.attribute :suffix, :string
+          # When true the suffix is space-separated ("D 1 Brochure") rather
+          # than the default dash ("R 60-sup"). Named for the RARE case with a
+          # false default, so the canonical to_hash drops it from every
+          # ordinary row.
+          base.attribute :space_suffix, :boolean, default: -> { false }
+        end
+
+        # Merged by lutaml with the block SingleIdentifier declares, which
+        # carries publisher/year/edition/stage/iteration.
+        def self.install_mappings(base)
+          base.key_value do
+            map "number", to: :number
+            map "part", to: :part
+            map "subpart", to: :subpart
+            map "suffix", to: :suffix
+            map "space_suffix", to: :space_suffix
+          end
+        end
+
+        # The composed document code, rebuilt on demand from the split columns
+        # so the renderer and the URN generator keep one place to ask for the
+        # printed form ("144-1", "60-sup"). Deliberately NOT an attribute and
+        # NOT memoised: the columns are writable (the base #exclude rebuilds
+        # through them), so a cached Code would go stale.
+        #
+        # nil when there is no number, preserving the old nil-`code` semantics
+        # the URN generator branches on.
+        def code
+          return nil if number.nil?
+
+          Components::Code.new(
+            number: number,
+            part: part,
+            subpart: subpart,
+            suffix: suffix,
+            space_suffix: space_suffix,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/document.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class Document < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "D"
         end

data/lib/pubid/oiml/identifiers/expert_report.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class ExpertReport < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "E"
         end

data/lib/pubid/oiml/identifiers/guide.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class Guide < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "G"
         end

data/lib/pubid/oiml/identifiers/recommendation.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class Recommendation < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "R"
         end

data/lib/pubid/oiml/identifiers/seminar_report.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class SeminarReport < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "S"
         end

data/lib/pubid/oiml/identifiers/vocabulary.rb

@@ -4,6 +4,8 @@ module Pubid
   module Oiml
     module Identifiers
       class Vocabulary < SingleIdentifier
+        include CodeNumber
+
         def type_string
           "V"
         end

data/lib/pubid/oiml/identifiers.rb

@@ -7,6 +7,7 @@ module Pubid
       autoload :Annex, "#{__dir__}/identifiers/annex"
       autoload :BasicPublication, "#{__dir__}/identifiers/basic_publication"
       autoload :Bulletin, "#{__dir__}/identifiers/bulletin"
+      autoload :CodeNumber, "#{__dir__}/identifiers/code_number"
       autoload :Document, "#{__dir__}/identifiers/document"
       autoload :Errata, "#{__dir__}/identifiers/errata"
       autoload :ExpertReport, "#{__dir__}/identifiers/expert_report"

data/lib/pubid/oiml/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Oiml
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 
@@ -122,9 +122,14 @@ module Pubid
         ).as(:edition_format) # Wrap entire match to capture that Edition was used
       end
 
-      # Date - year after colon OR edition portion (with optional space before year)
+      # Date - year after colon, the VIM's paren-year form ("OIML V 2-200
+      # (2000)" — space + (YYYY) instead of :YYYY, the shape #342 flags as
+      # the one real-world spelling that did not parse), OR edition portion
+      # (with optional space before year)
       rule(:date) do
-        edition_portion | (colon >> space.maybe >> year_digits.as(:year))
+        edition_portion |
+          (colon >> space.maybe >> year_digits.as(:year)) |
+          (space.maybe >> lparen >> year_digits.as(:year) >> rparen)
       end
 
       # Draft stage - WD or CD with optional iteration

data/lib/pubid/oiml/renderer.rb

@@ -65,7 +65,7 @@ module Pubid
         result = "#{id.publisher} Bulletin"
         if id.date&.year
           result += " #{id.date.year}"
-          result += "-#{id.issue}" if id.issue
+          result += "-#{id.number}" if id.number
           result += "-#{id.sequence}" if id.sequence
         end
         result += " (#{id.language})" if id.language
@@ -77,9 +77,9 @@ module Pubid
       # structured since OIML's citation format doesn't define volume-only
       # or issue-only variants.
       def render_bulletin_citation(id)
-        return render_bulletin_structured(id) unless id.date&.year && id.issue && id.sequence
+        return render_bulletin_structured(id) unless id.date&.year && id.number && id.sequence
 
-        "#{id.publisher} Bulletin #{id.volume_roman}(#{id.issue.to_i}) #{id.article_id}"
+        "#{id.publisher} Bulletin #{id.volume_roman}(#{id.number.to_i}) #{id.article_id}"
       end
 
       def effective_format(id)

data/lib/pubid/oiml/single_identifier.rb

@@ -5,7 +5,6 @@ module Pubid
     class SingleIdentifier < Identifier
       # Base class for OIML single identifiers (non-supplements)
       attribute :publisher, :string
-      attribute :code, Oiml::Components::Code
       attribute :date, Pubid::Components::Date
       attribute :edition, :string
       attribute :stage, :string
@@ -16,46 +15,24 @@ module Pubid
       } # Track parsed format
 
       # Serialization delta on top of Oiml::Identifier's shared block. The
-      # `code` (number/part/subpart/suffix) and `date` (year) components are
-      # flattened to top-level keys rather than nested hashes, mirroring ISO
-      # (lib/pubid/iso/identifier.rb). `type` is intentionally omitted
-      # (recomputed from the class on load).
+      # `date` (year) component is flattened to a top-level key rather than a
+      # nested hash, mirroring ISO (lib/pubid/iso/identifier.rb). `type` is
+      # intentionally omitted (recomputed from the class on load).
+      #
+      # The code columns (number/part/subpart/suffix/space_suffix) are NOT
+      # here: they are declared, and mapped, by Identifiers::CodeNumber on each
+      # concrete leaf, because redefining the inherited `number` on this class
+      # — which every leaf inherits — is the multi-flavor determinism landmine.
+      # Keeping the mapping with the attribute is also what lets Bulletin, the
+      # one leaf with no code, declare its own `number` (the issue) and map it.
       key_value do
         map "publisher", to: :publisher
-        map "number", with: { to: :number_to_kv, from: :number_from_kv }
-        map "part", with: { to: :part_to_kv, from: :part_from_kv }
-        map "subpart", with: { to: :subpart_to_kv, from: :subpart_from_kv }
-        map "suffix", with: { to: :suffix_to_kv, from: :suffix_from_kv }
-        map "space_suffix",
-            with: { to: :space_suffix_to_kv, from: :space_suffix_from_kv }
         map "year", with: { to: :year_to_kv, from: :year_from_kv }
         map "edition", to: :edition
         map "stage", to: :stage
         map "iteration", to: :iteration
       end
 
-      # --- code components flattened to top-level keys ---
-      def number_to_kv(model, doc) = emit_kv(doc, "number", model.code&.number)
-      def number_from_kv(model, value) = code_for(model).number = value.to_s
-      def part_to_kv(model, doc) = emit_kv(doc, "part", model.code&.part)
-      def part_from_kv(model, value) = code_for(model).part = value.to_s
-      def subpart_to_kv(model, doc) = emit_kv(doc, "subpart", model.code&.subpart)
-      def subpart_from_kv(model, value) = code_for(model).subpart = value.to_s
-      def suffix_to_kv(model, doc) = emit_kv(doc, "suffix", model.code&.suffix)
-      def suffix_from_kv(model, value) = code_for(model).suffix = value.to_s
-
-      def space_suffix_to_kv(model, doc)
-        return unless model.code&.space_suffix
-
-        doc.add_child(
-          Lutaml::KeyValue::DataModel::Element.new("space_suffix", true),
-        )
-      end
-
-      def space_suffix_from_kv(model, value)
-        code_for(model).space_suffix = value
-      end
-
       # --- date flattened to a top-level year ---
       def year_to_kv(model, doc) = emit_kv(doc, "year", model.date&.year)
 
@@ -69,10 +46,6 @@ module Pubid
         doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, value.to_s))
       end
 
-      def code_for(model)
-        model.code ||= Components::Code.new
-      end
-
       attr_reader :requested_format
 
       # Type is determined by the subclass
@@ -103,11 +76,15 @@ module Pubid
         raise NotImplementedError, "Subclasses must implement type_string"
       end
 
-      # OIML keeps identity in `code` (Components::Code) and `type_string`
-      # (e.g. "R", "V", "D"), not in the inherited `number`/`typed_stage` —
-      # the generic MrString renderer would otherwise drop both and produce
-      # `OIML.<year>`. Losslessness for issue #142 requires the type letter
-      # and document number to appear in MR.
+      # OIML keeps identity in the code columns and `type_string` (e.g. "R",
+      # "V", "D"), not in the inherited `typed_stage` — the generic MrString
+      # renderer would otherwise drop both and produce `OIML.<year>`.
+      # Losslessness for issue #142 requires the type letter and document
+      # number to appear in MR.
+      #
+      # Reads through `code`, which every code-bearing leaf composes from its
+      # split columns (Identifiers::CodeNumber); Bulletin has no code and
+      # returns nil here, keeping its (year, issue, sequence) slug.
       def mr_number_with_part
         segments = []
         segments << code&.number&.to_s if code&.number
@@ -119,6 +96,13 @@ module Pubid
         segments.join("-")
       end
 
+      # Bulletin overrides `code`; every other leaf gets it from
+      # Identifiers::CodeNumber. Returning nil here keeps #== , the renderer
+      # and the URN generator total for the abstract class itself.
+      def code
+        nil
+      end
+
       def mr_type
         type_string&.downcase
       end