pubid 2.0.0.pre.alpha.5 → 2.0.0.pre.alpha.7

data/lib/pubid/iala/urn_parser.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Parses IALA MRN URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:mrn:iala:pub:<type-lower><number>[:ed<edition>][:<lang-lower>]
+    #
+    # Examples:
+    #   urn:mrn:iala:pub:s1070:ed2.0          → IALA S1070 Ed 2.0
+    #   urn:mrn:iala:pub:r1016:ed2.0:f        → IALA R1016 Ed 2.0 (F)
+    #   urn:mrn:iala:pub:c0103-1              → IALA C0103-1
+    class UrnParser < Pubid::UrnParser::Base
+      PREFIX = "urn:mrn:iala:pub:".freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        code = parts.fetch(0)
+
+        edition = nil
+        language = nil
+        parts.drop(1).each do |seg|
+          if seg.start_with?("ed")
+            edition = seg.sub(/\Aed/, "")
+          elsif seg.length == 1 && seg.match?(/\A[a-z]\z/i)
+            language = seg.upcase
+          end
+        end
+
+        text = "IALA #{code.upcase}"
+        text += " Ed #{edition}" if edition
+        text += " (#{language})" if language
+        flavor_parse(text)
+      end
+
+      private
+
+      def strip_namespace(urn)
+        unless urn.downcase.start_with?(PREFIX)
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid IALA URN: #{urn.inspect}"
+        end
+
+        urn[PREFIX.length..]
+      end
+    end
+  end
+end

data/lib/pubid/iala.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    extend Pubid::PrefixesSupport
+
+    # Sole IALA publisher token (see the parser's `publisher` rule).
+    PREFIXES = ["IALA"].freeze
+
+    autoload :Builder,      "#{__dir__}/iala/builder"
+    autoload :Identifier,   "#{__dir__}/iala/identifier"
+    autoload :Identifiers,  "#{__dir__}/iala/identifiers"
+    autoload :Parser,       "#{__dir__}/iala/parser"
+    autoload :Renderer,     "#{__dir__}/iala/renderer"
+    autoload :UrnGenerator, "#{__dir__}/iala/urn_generator"
+    autoload :UrnParser,    "#{__dir__}/iala/urn_parser"
+
+    # Parse an IALA identifier string into an identifier object.
+    # @param identifier [String] The IALA identifier string to parse
+    # @return [Pubid::Iala::Identifier]
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifiers::Base.format_registry.register(:human, renderer: Iala::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c < Pubid::Identifier }
+        .reject { |c| c == Identifiers::Base }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>]
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol]
+    # @return [Class, nil]
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol]
+    # @return [Pubid::Components::TypedStage, nil]
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+
+    # Look up an identifier class by its IALA type letter (S, R, G, M, C, X, P).
+    # @param letter [String]
+    # @return [Class<Identifiers::Base>]
+    def self.identifier_klass_for_type_letter(letter)
+      @by_letter ||= identifier_types.to_h { |klass| [klass.type[:short], klass] }
+      @by_letter.fetch(letter.to_s.upcase)
+    end
+  end
+end
+
+Pubid::Registry.register(:iala, Pubid::Iala)

data/lib/pubid/identifier.rb

@@ -120,6 +120,13 @@ module Pubid
       nil
     end
 
+    # The underlying standard, with amendment / corrigendum / Expert-commentary
+    # / Flex-version wrappers peeled recursively. Wrapper subclasses override
+    # this; a plain identifier is its own base document.
+    def base_document
+      self
+    end
+
     # @return [String, nil] publication year from the date component
     def year
       date&.year&.to_s
@@ -311,17 +318,48 @@ module Pubid
       Pubid::UrnGenerator::Base
     end
 
+    # Excluded attributes are nilled; every other value is passed through
+    # #exclude_from_nested so the exclusion also propagates into nested
+    # identifiers — wrapper types (adopted standards, consolidated amendments,
+    # expert-commentary wrappers) delegate their date to an inner identifier
+    # rather than storing it in their own attribute.
     def exclude(*args)
+      # :amendment / :supplement are structural, not attributes — they reduce
+      # a supplemented identifier to the standard it wraps (#drop_supplements).
+      supplement_keys = args & %i[amendment supplement]
+      unless supplement_keys.empty?
+        return drop_supplements.exclude(*(args - supplement_keys))
+      end
+
       excluded_args = args.dup
       # Map :year to :date since identifiers store years inside date
       excluded_args << :date if excluded_args.delete(:year)
 
       attrs = self.class.attributes.each_with_object({}) do |(name, _), h|
-        h[name] = excluded_args.include?(name) ? nil : public_send(name)
+        value = excluded_args.include?(name) ? nil : public_send(name)
+        h[name] = exclude_from_nested(value, args)
       end
       self.class.new(attrs)
     end
 
+    # The standard this identifier supplements, dropping its own supplement
+    # layer (one level). Overridden by ConsolidatedIdentifier / Amendment /
+    # Corrigendum; a non-supplement identifier supplements nothing, so it is
+    # returned unchanged.
+    def drop_supplements
+      self
+    end
+
+    # Fuzz-level equality: two identifiers match when they are equal after
+    # excluding the given aspects. `ignore` accepts the same symbols as #exclude
+    # (e.g. :date, :edition, :amendment). This is the primitive relaton uses to
+    # match a reference against catalogue hits at varying strictness.
+    def matches?(other, ignore: [])
+      return false unless other.is_a?(::Pubid::Identifier)
+
+      exclude(*ignore) == other.exclude(*ignore)
+    end
+
     def new_edition_of?(other)
       unless publisher == other.publisher
         raise ArgumentError,
@@ -362,6 +400,21 @@ module Pubid
 
     private
 
+    # Propagate an #exclude into a nested attribute value: recurse when it is
+    # (or contains) another identifier, otherwise return it unchanged.
+    # Components and scalars are copied as-is. Passes the original args so
+    # nested identifiers re-apply the same :year->:date mapping themselves.
+    def exclude_from_nested(value, args)
+      case value
+      when ::Pubid::Identifier
+        value.exclude(*args)
+      when Array
+        value.map { |item| exclude_from_nested(item, args) }
+      else
+        value
+      end
+    end
+
     def build_rendering_context(_renderer, format:, with_edition: false,
                                 lang: :en, lang_single: false,
                                 stage_format_long: nil, with_date: nil,

data/lib/pubid/idf.rb

@@ -2,6 +2,11 @@
 
 module Pubid
   module Idf
+    extend Pubid::PrefixesSupport
+
+    # Sole IDF publisher token (see the parser's `prefix_sole_publisher` rule).
+    PREFIXES = ["IDF"].freeze
+
     autoload :Builder, "#{__dir__}/idf/builder"
     autoload :Identifier, "#{__dir__}/idf/identifier"
     autoload :Identifiers, "#{__dir__}/idf/identifiers"

data/lib/pubid/iec.rb

@@ -3,6 +3,14 @@
 module Pubid
   module Iec
     autoload :Components, "#{__dir__}/iec/components"
+
+    extend Pubid::PrefixesSupport
+
+    # Sourced from the parser's publisher list (Components::Publisher::PUBLISHERS)
+    # minus the joint "ISO/IEC", which is contributed symmetrically via
+    # Pubid::JOINT_PREFIXES (along with IEC/ISO and ISO/IEC/IEEE).
+    PREFIXES = (Components::Publisher::PUBLISHERS.keys - ["ISO/IEC"]).freeze
+
     autoload :Identifier, "#{__dir__}/iec/identifier"
     autoload :Identifiers, "#{__dir__}/iec/identifiers"
     autoload :SingleIdentifier, "#{__dir__}/iec/single_identifier"

data/lib/pubid/ieee.rb

@@ -2,6 +2,14 @@
 
 module Pubid
   module Ieee
+    extend Pubid::PrefixesSupport
+
+    # Publisher prefix. The private PreParser::PUBLISHERS list also holds adopted
+    # co-org names (ANSI, AIEE, ASA, ...) that are not leading routing tokens for
+    # an IEEE reference, so they are deliberately excluded. The joint ISO/IEC/IEEE
+    # form comes from Pubid::JOINT_PREFIXES.
+    PREFIXES = ["IEEE"].freeze
+
     autoload :Aiee, "#{__dir__}/ieee/aiee"
     autoload :Builder, "#{__dir__}/ieee/builder"
     autoload :Identifier, "#{__dir__}/ieee/identifier"

data/lib/pubid/iho.rb

@@ -2,6 +2,11 @@
 
 module Pubid
   module Iho
+    extend Pubid::PrefixesSupport
+
+    # Sole IHO publisher token (see the parser grammar).
+    PREFIXES = ["IHO"].freeze
+
     autoload :Builder,      "#{__dir__}/iho/builder"
     autoload :Identifier,   "#{__dir__}/iho/identifier"
     autoload :Identifiers,  "#{__dir__}/iho/identifiers"

data/lib/pubid/iso.rb

@@ -4,6 +4,12 @@ require "lutaml/model"
 
 module Pubid
   module Iso
+    extend Pubid::PrefixesSupport
+
+    # Sole ISO publisher token. Joint / co-publication forms (ISO/IEC, IEC/ISO,
+    # ISO/IEC/IEEE) are contributed symmetrically via Pubid::JOINT_PREFIXES.
+    PREFIXES = ["ISO"].freeze
+
     autoload :Builder, "#{__dir__}/iso/builder"
     autoload :BundledIdentifier, "#{__dir__}/iso/bundled_identifier"
     autoload :CombinedIdentifier, "#{__dir__}/iso/combined_identifier"

data/lib/pubid/itu.rb

@@ -4,6 +4,11 @@ require "lutaml/model"
 
 module Pubid
   module Itu
+    extend Pubid::PrefixesSupport
+
+    # Sole ITU publisher token (see the parser's `itu_prefix` rule).
+    PREFIXES = ["ITU"].freeze
+
     autoload :Builder, "#{__dir__}/itu/builder"
     autoload :Components, "#{__dir__}/itu/components"
     autoload :Identifier, "#{__dir__}/itu/identifier"

data/lib/pubid/jcgm.rb

@@ -2,6 +2,11 @@
 
 module Pubid
   module Jcgm
+    extend Pubid::PrefixesSupport
+
+    # Sole JCGM publisher token (see the parser's `publisher` rule).
+    PREFIXES = ["JCGM"].freeze
+
     autoload :Builder, "#{__dir__}/jcgm/builder"
     autoload :Components, "#{__dir__}/jcgm/components"
     autoload :Identifier, "#{__dir__}/jcgm/identifier"

data/lib/pubid/jis.rb

@@ -2,6 +2,12 @@
 
 module Pubid
   module Jis
+    extend Pubid::PrefixesSupport
+
+    # Sole JIS publisher token (see the parser's `jis_prefix` rule). Document
+    # types (TR/TS) follow the JIS prefix and are excluded.
+    PREFIXES = ["JIS"].freeze
+
     autoload :Builder, "#{__dir__}/jis/builder"
     autoload :Identifier, "#{__dir__}/jis/identifier"
     autoload :Identifiers, "#{__dir__}/jis/identifiers"

data/lib/pubid/nist.rb

@@ -2,6 +2,19 @@
 
 module Pubid
   module Nist
+    extend Pubid::PrefixesSupport
+
+    # Publisher prefixes (NBS/NIST) plus the "simple series" tokens that can
+    # *begin* a printed reference on their own — mirrors the parser's
+    # `publisher` and `simple_series` rules (lib/pubid/nist/parser.rb). Compound
+    # series that only appear glued to a publisher (e.g. "NBS CRPL-F-A") are
+    # excluded because they never lead a routable reference by themselves.
+    PREFIXES = %w[
+      NIST NBS
+      AMS VTS BSS BMS BH FIPS GCR HB MONO MP NCSTAR NSRDS IR SP TN CSWP
+      AI CIRC CS CSM CRPL LCIRC OWMWP PC RPT SIBS TIBM TTB EAB JPCRD JRES
+    ].freeze
+
     autoload :Builder, "#{__dir__}/nist/builder"
     autoload :Caster, "#{__dir__}/nist/caster"
     autoload :CircularSupplementBuilder, "#{__dir__}/nist/circular_supplement_builder"

data/lib/pubid/oiml/builder.rb

@@ -6,6 +6,7 @@ module Pubid
       # Type to identifier class mapping (MECE)
       TYPE_CLASS_MAP = {
         "B" => "BasicPublication",
+        "Bulletin" => "Bulletin",
         "D" => "Document",
         "E" => "ExpertReport",
         "G" => "Guide",
@@ -175,12 +176,26 @@ module Pubid
           identifier.date = Pubid::Components::Date.new(year: year_value.to_s)
         end
 
+        # Bulletin-specific locator fields. The structured form captures
+        # issue/sequence directly; the citation form captures volume/issue/
+        # article_id, which we decode to the same (year, issue, sequence)
+        # tuple. Year comes from either the date rule (structured) or the
+        # article_id (citation).
+        if identifier.is_a?(Identifiers::Bulletin)
+          apply_bulletin_locator(identifier, parsed_hash)
+        end
+
         # Determine parsed format for round-trip fidelity
         # If edition_format was captured, it means "Edition" text was present
         identifier.parsed_format = if parsed_hash[:edition_format]
                                      "long"
                                    elsif parsed_hash[:space_before_lang]
                                      "short_with_space"
+                                   elsif parsed_hash[:article_id]
+                                     # Bulletin citation form — preserve on
+                                     # the identifier so default to_s gives
+                                     # back the citation string verbatim.
+                                     "citation"
                                    else
                                      "short"
                                    end
@@ -195,6 +210,24 @@ module Pubid
         identifier
       end
 
+      # Populate issue/sequence on a Bulletin from either parse shape.
+      # Structured: :issue and :sequence captured directly as zero-padded
+      # strings. Citation: :volume_roman, :issue_arabic, :article_id —
+      # decode the 8-digit article_id to recover year+issue+sequence.
+      def apply_bulletin_locator(identifier, parsed_hash)
+        if parsed_hash[:article_id]
+          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.sequence = article_id[6, 2]
+          return
+        end
+
+        identifier.issue = parsed_hash[:issue].to_s if parsed_hash[:issue]
+        identifier.sequence = parsed_hash[:sequence].to_s if parsed_hash[:sequence]
+      end
+
       def extract_language(lang_data)
         # Handle both direct string and nested hash from parser
         case lang_data

data/lib/pubid/oiml/identifier.rb

@@ -10,6 +10,7 @@ module Pubid
       OIML_TYPE_MAP = {
         "pubid:oiml:recommendation" => "Pubid::Oiml::Identifiers::Recommendation",
         "pubid:oiml:basic-publication" => "Pubid::Oiml::Identifiers::BasicPublication",
+        "pubid:oiml:bulletin" => "Pubid::Oiml::Identifiers::Bulletin",
         "pubid:oiml:document" => "Pubid::Oiml::Identifiers::Document",
         "pubid:oiml:guide" => "Pubid::Oiml::Identifiers::Guide",
         "pubid:oiml:vocabulary" => "Pubid::Oiml::Identifiers::Vocabulary",

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      # OIML Bulletin issues and articles. Carries no code — the locator is
+      # the (year, issue, sequence) tuple drawn from the issue's place in the
+      # periodical hierarchy.
+      #
+      # Two input forms are accepted, both referring to the same article:
+      #
+      #   structured:  "OIML Bulletin 2026-02-11"
+      #   citation:    "OIML Bulletin LXVII(2) 20260211"
+      #
+      # The structured form is the dataset's primary docid (sortable,
+      # deterministic). The citation form is what OIML prints on the article
+      # page (`Citation: AUTHOR YEAR OIML Bulletin VOLUME(ISSUE) ARTID`).
+      #
+      # Volume tracks year deterministically: 1960 = I, year - 1959 = volume.
+      # The 8-digit article id is YYYYNNSS — the same three values concatenated,
+      # so the citation form is decoded entirely from the article id; the
+      # roman volume and parenthesised issue are redundant display.
+      #
+      # Shapes in relaton-data-oiml:
+      #   "OIML Bulletin"                       (periodical)
+      #   "OIML Bulletin 1960"                  (volume / year)
+      #   "OIML Bulletin 1960-03"               (issue)
+      #   "OIML Bulletin 1960-03-01"            (article, structured)
+      #   "OIML Bulletin LXVII(2) 20260211"     (article, citation)
+      class Bulletin < SingleIdentifier
+        # OIML Bulletin volume I was issued in 1960. Volume N corresponds to
+        # year (N + BASE_YEAR_OFFSET). Used to translate between the year
+        # 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
+        # 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 "sequence", to: :sequence
+        end
+
+        def type_string
+          "Bulletin"
+        end
+
+        # Volume as an arabic string ("67"), derived from the year. nil when
+        # the year is absent (bare periodical reference).
+        def volume_arabic
+          return nil unless date&.year
+
+          (date.year.to_i - BASE_YEAR_OFFSET).to_s
+        end
+
+        # 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?
+
+          self.class.to_roman(number)
+        end
+
+        # 8-digit oiml.org article id ("20260211"). Composed by concatenating
+        # year + issue + sequence. nil unless all three are present.
+        def article_id
+          return nil unless date&.year && issue && sequence
+
+          "#{date.year}#{issue}#{sequence}"
+        end
+
+        class << self
+          # Convert a positive integer to its roman-numeral representation.
+          # Used to render the citation form. The dataset already stores the
+          # roman volume verbatim in `extent.locality`, so this conversion is
+          # only needed when rendering from the structured form.
+          def to_roman(number)
+            raise ArgumentError, "volume must be > 0" unless number.positive?
+
+            ROMAN_TABLE.each_with_object(+"") do |(value, sym), result|
+              quotient, number = number.divmod(value)
+              result << (sym * quotient)
+            end.freeze
+          end
+
+          ROMAN_TABLE = [
+            [1000, "M"], [900, "CM"], [500, "D"], [400, "CD"],
+            [100, "C"], [90, "XC"], [50, "L"], [40, "XL"],
+            [10, "X"], [9, "IX"], [5, "V"], [4, "IV"],
+            [1, "I"]
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers.rb

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

data/lib/pubid/oiml/parser.rb

@@ -20,7 +20,7 @@ module Pubid
       rule(:identifier) do
         amendment_identifier | amendment_short | annex_letter_identifier |
           annex_identifier | plus_supplement_identifier |
-          trailing_supplement_identifier | base_identifier
+          trailing_supplement_identifier | bulletin_identifier | base_identifier
       end
 
       # Publisher - always "OIML"
@@ -29,6 +29,48 @@ module Pubid
       # Document type - single letter
       rule(:doc_type) { match("[BDEGRSVX]").as(:type) >> space }
 
+      # Bulletin locator — structured form. Year optionally followed by
+      # 2-digit issue and 2-digit sequence:
+      #   "OIML Bulletin", "OIML Bulletin 1960",
+      #   "OIML Bulletin 1960-03", "OIML Bulletin 1960-03-01"
+      # All four shapes appear as primary docids in relaton-data-oiml.
+      rule(:bulletin_date) do
+        space >> year_digits.as(:year) >>
+          (dash >> two_digits.as(:issue)).maybe >>
+          (dash >> two_digits.as(:sequence)).maybe
+      end
+
+      # Two-digit zero-padded number (used for issue / sequence).
+      rule(:two_digits) { match('\d').repeat(2, 2) }
+
+      # Roman numeral token composed of I,V,X,L,C,D,M (uppercase, matching
+      # OIML's print convention). Consumed but not captured — the 8-digit
+      # article id in the same citation carries year/issue/sequence
+      # deterministically, so the roman volume is redundant for parsing.
+      rule(:roman_numeral) { match("[IVXLCDM]").repeat(1) }
+
+      # Bulletin locator — citation form. The format OIML prints on the
+      # article page is: "LXVII(2) 20260211" where LXVII is the volume in
+      # roman numerals, (2) is the issue in arabic without zero padding,
+      # and 20260211 is the 8-digit oiml.org article id (YYYYNNSS).
+      rule(:bulletin_citation) do
+        space >> roman_numeral >>
+          lparen >> digits.as(:issue_arabic) >> rparen >>
+          space >> match('\d').repeat(8, 8).as(:article_id)
+      end
+
+      # Bulletin identifier — no code; the locator (when present) is the
+      # (year, issue, sequence) tuple drawn from either the structured
+      # YYYY-II-SS form or the citation VOLUME(ISSUE) ARTID form. Both
+      # decode to the same record. Tried before base_identifier because
+      # "Bulletin" is a word that the single-letter doc_type rule cannot
+      # match.
+      rule(:bulletin_identifier) do
+        publisher >> str("Bulletin").as(:type) >>
+          (bulletin_citation | bulletin_date).maybe >>
+          language_portion.maybe.as(:language)
+      end
+
       # Number with optional part and subpart
       rule(:number_only) { digits.as(:number) }
 

data/lib/pubid/oiml/renderer.rb

@@ -20,6 +20,8 @@ module Pubid
         case id
         when Identifiers::Annex
           render_annex(id)
+        when Identifiers::Bulletin
+          render_bulletin(id)
         when SupplementIdentifier
           render_supplement(id)
         when SingleIdentifier
@@ -31,6 +33,55 @@ module Pubid
 
       private
 
+      # Render the Bulletin in the requested or parsed form. Default is the
+      # structured "YYYY-II-SS" form (the dataset's primary docid). The
+      # citation form ("LXVII(2) 20260211") is emitted when the user asks
+      # for it via `to_s(format: :citation)` or when the identifier was
+      # itself parsed from a citation string (parsed_format == "citation").
+      def render_bulletin(id)
+        if citation_form?(id)
+          render_bulletin_citation(id)
+        else
+          render_bulletin_structured(id)
+        end
+      end
+
+      # User's explicit format request takes precedence over the parsed
+      # form, so `parse("LXVII(2) 20260211").to_s(format: :short)` returns
+      # the structured form. With no explicit request, the parsed form is
+      # preserved for round-trip fidelity.
+      def citation_form?(id)
+        case id.requested_format
+        when :citation then true
+        when :short, :structured then false
+        else
+          id.parsed_format == "citation"
+        end
+      end
+
+      # "OIML Bulletin" / "OIML Bulletin 1960" / "OIML Bulletin 1960-03" /
+      # "OIML Bulletin 1960-03-01". No code; the locator is space-separated.
+      def render_bulletin_structured(id)
+        result = "#{id.publisher} Bulletin"
+        if id.date&.year
+          result += " #{id.date.year}"
+          result += "-#{id.issue}" if id.issue
+          result += "-#{id.sequence}" if id.sequence
+        end
+        result += " (#{id.language})" if id.language
+        result
+      end
+
+      # "OIML Bulletin LXVII(2) 20260211". Only emitted for full articles
+      # (year + issue + sequence all present); lower tiers fall back to
+      # 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
+
+        "#{id.publisher} Bulletin #{id.volume_roman}(#{id.issue.to_i}) #{id.article_id}"
+      end
+
       def effective_format(id)
         id.requested_format ||
           (id.parsed_format == "long" ? :long : :short)