pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.11

data/lib/pubid/oasis/builder.rb

@@ -4,15 +4,17 @@ module Pubid
   module Oasis
     # Turns the parse tree into an `Identifiers::Standard`: stores the slug
     # verbatim in `original`, then performs a best-effort, ORDER-INDEPENDENT
-    # decomposition into spec / version / stage / part / label.
+    # decomposition into number / version / stage / part / label.
     #
     # Decomposition splits `original` on "-" and classifies each *whole*
     # fragment (so a stage-like substring inside a spec name — e.g. "CSDL" — is
-    # never mistaken for a stage). `spec` is the run of leading name fragments
-    # before the first recognized fragment; `version`/`stage`/`part` are the
-    # first fragment of each recognized kind; `label` is any name fragment
-    # appearing after the first recognized one. Anything the classifier cannot
-    # place stays only in `original`, so the printed form always round-trips.
+    # never mistaken for a stage). `number` is the specification name: the run
+    # of leading name fragments before the first recognized fragment, and the
+    # key relaton-index sorts and binary-searches on. `version`/`stage`/`part`
+    # are the first fragment of each recognized kind; `label` is any name
+    # fragment appearing after the first recognized one. Anything the
+    # classifier cannot place stays only in `original`, so the printed form
+    # always round-trips.
     class Builder
       # A fragment is a version when it is `v?N(.N)+` (e.g. "3.0", "v1.2.1",
       # "V1.0"). Bare integers are deliberately NOT versions (too ambiguous
@@ -36,16 +38,16 @@ module Pubid
 
       private
 
-      # @return [Hash] best-effort { spec:, version:, stage:, part:, label: }.
-      # Each fragment is classified once into a [fragment, kind] pair. `spec` is
-      # the leading run of name fragments; `label` is any name fragment after
+      # @return [Hash] best-effort { number:, version:, stage:, part:, label: }.
+      # Each fragment is classified once into a [fragment, kind] pair. `number`
+      # is the leading run of name fragments; `label` is any name fragment after
       # the first recognized one; version/stage/part are the first of each kind.
       def decompose(original)
         pairs = original.split("-").map { |f| [f, classify(f)] }
         lead = pairs.take_while { |_, kind| kind.nil? }
         rest = pairs.drop(lead.length)
         {
-          spec: names(lead),
+          number: names(lead),
           version: first_of(rest, :version),
           stage: first_of(rest, :stage),
           part: first_of(rest, :part),

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

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

@@ -45,6 +45,42 @@ module Pubid
           map "sequence", to: :sequence
         end
 
+        # relaton-index keys on `id.root.number.to_s`. Bulletin is the one OIML
+        # leaf with no code (it does not include Identifiers::CodeNumber), so
+        # it derives the key from the year it already stores: every issue and
+        # article of a volume clusters into one bucket, with per-article
+        # distinctness coming from the MR slug instead. That is the BIPM
+        # Metrologia-volume precedent recorded in CLAUDE.md.
+        #
+        # A DERIVED READER, deliberately not an attribute: storing it would
+        # duplicate `year` in every row, and the key_value block above maps no
+        # "number", so nothing is added to the wire format. Safe as a plain
+        # method because Bulletin declares no `number` attribute of its own
+        # (the ITU itu/identifiers/base.rb precedent).
+        #
+        # nil for the bare periodical reference "OIML Bulletin", which names no
+        # year — a deliberate gap, pinned in spec/pubid/oiml/root_number_spec.rb.
+        def number
+          date&.year&.to_s
+        end
+
+        # The index key above is deliberately coarse — a whole volume in one
+        # bucket — which is only defensible because the MR slug stays
+        # per-article. 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 = [issue, sequence].compact
+          return nil if segments.empty?
+
+          segments.join("-")
+        end
+
         def type_string
           "Bulletin"
         end

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 a permanently-nil `number` and a `number` key that never appears.
+      # It derives its index key from the year 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
 

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, omit both.
       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

data/lib/pubid/oiml/supplement_identifier.rb

@@ -8,6 +8,33 @@ module Pubid
       attribute :base, Oiml::Identifier, polymorphic: true
       attribute :year, :string
       attribute :language, :string
+
+      # Delegate the document code to the wrapped standard, mirroring
+      # Pubid::Etsi::Identifiers::SupplementIdentifier#code.
+      #
+      # PRE-EXISTING BUG this closes: `UrnGenerator#urn_number` calls
+      # `identifier.code` for every non-Bulletin type, but a supplement
+      # descends from Oiml::Identifier directly — it is a SIBLING of
+      # SingleIdentifier, which is where `code` used to live — so it inherited
+      # no `code` at all and `to_urn` raised NoMethodError for every Amendment,
+      # Errata and Annex. Verified against a baseline captured on main: all
+      # five supplement fixtures already raised there, so this is a fix, not a
+      # regression introduced by the move to split index columns.
+      #
+      # It stayed hidden because spec/pubid/oiml/urn_spec.rb only exercises a
+      # bare Recommendation and spec/pubid/oiml/fixtures_spec.rb globs a bad
+      # path and runs 0 examples (hand-off: ten-dead-fixture-specs).
+      # `iteration` is the same story: declared on SingleIdentifier, read
+      # unconditionally by UrnGenerator#urn_iteration, absent from the
+      # supplement branch of the hierarchy. (`stage` escapes because
+      # ::Pubid::Identifier declares one, so it merely returns nil.)
+      def code
+        base&.code
+      end
+
+      def iteration
+        base&.iteration
+      end
       # True for the trailing-word shorthand ("OIML R 138:2009 Amendment"),
       # where the supplement word is appended after a dated base instead of the
       # "Amendment (YYYY) to BASE" prose form. The word itself comes from the