pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/bipm/identifiers/si_brochure.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    module Identifiers
+      # The SI Brochure — a single bespoke record. The English form drops the
+      # "sur le SI" phrase the French form carries.
+      #
+      # Printed forms (both round-trip):
+      #   "BIPM SI Brochure 9e v3.01 (2019/2024, E)"
+      #   "BIPM SI Brochure sur le SI 9e v3.01 (2019/2024, F)"
+      class SiBrochure < Identifier
+        def self.type
+          { key: :si_brochure, web: :si_brochure,
+            title: "SI Brochure", short: "si-brochure" }
+        end
+
+        # MR: `bipm.si-brochure.<edition>-<version>[.<lang>]` for the brochure
+        # itself, `bipm.si-brochure.<variant>` for a derived product. Exactly
+        # one of `variant` / `edition` is set (the grammar guarantees it).
+        def mr_type
+          "si-brochure"
+        end
+
+        # The edition is folded in here rather than emitted through
+        # `mr_edition`, whose base implementation expects a Components::Edition.
+        def mr_number_with_part
+          variant ? mr_slug(variant) : mr_slug(edition, version)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/bipm/identifiers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    # Namespace for concrete BIPM identifier types.
+    module Identifiers
+      autoload :CommitteeDocument, "#{__dir__}/identifiers/committee_document"
+      autoload :Guide, "#{__dir__}/identifiers/guide"
+      autoload :Meeting, "#{__dir__}/identifiers/meeting"
+      autoload :Mep, "#{__dir__}/identifiers/mep"
+      autoload :MetrologiaArticle, "#{__dir__}/identifiers/metrologia_article"
+      autoload :SiBrochure, "#{__dir__}/identifiers/si_brochure"
+    end
+  end
+end

data/lib/pubid/bipm/parser.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Bipm
+    # Parslet grammar for the four BIPM identifier families. The root branches
+    # by leading token / shape; each alternative is wrapped in a distinct key
+    # (:committee_short, :meeting_en, …) so the Builder can dispatch on the
+    # matched branch without re-inspecting the string.
+    #
+    # Group and type-word alternations are built from the shared vocabularies on
+    # {Identifier} (sorted longest-first so e.g. "CCTF" is tried before "CCT").
+    class Parser < ::Pubid::Parser::Grammar
+      # --- primitives ---
+      rule(:space) { str(" ") }
+      rule(:digits) { match["0-9"].repeat(1) }
+      rule(:alnum) { match["0-9A-Za-z"].repeat(1) }
+      # Number, preserved as a string: digits with optional hyphenated parts.
+      rule(:number) do
+        (digits >> (str("-") >> digits).repeat).as(:number)
+      end
+      rule(:year) { match["0-9"].repeat(4, 4).as(:year) }
+      # "E"/"F" as BIPM prints them, plus the two-letter codes consumer
+      # references use (longest first, so "EN" is never read as a bare "E").
+      rule(:lang) do
+        (str("EN") | str("FR") | match["EF"]).as(:language)
+      end
+      # "(YYYY)" or "(YYYY, E)"
+      rule(:year_paren) do
+        str("(") >> year >> (str(", ") >> lang).maybe >> str(")")
+      end
+      rule(:year_paren_nolang) { str("(") >> year >> str(")") }
+
+      # Longest-first alternation over a list of literal tokens, so a token that
+      # is a prefix of another (e.g. "CCT" of "CCTF") never shadows it.
+      def alternation(tokens)
+        tokens.sort_by { |t| -t.length }.map { |t| str(t) }.reduce(:|)
+      end
+
+      rule(:group) { alternation(Identifier::PARSEABLE_GROUPS).as(:group) }
+
+      rule(:type_abbrev) do
+        alternation(Identifier::TYPE_CODES).as(:type_word)
+      end
+      rule(:type_name_en) do
+        names = Identifier::TYPE_NAME_EN.values.uniq + ["Declaration"]
+        alternation(names).as(:type_word)
+      end
+      rule(:type_name_fr) do
+        names = Identifier::TYPE_NAME_FR.values.uniq + ["Déclaration"]
+        alternation(names).as(:type_word)
+      end
+      rule(:connective) { str("de la") | str("du") }
+      rule(:ordinal) { str("st") | str("nd") | str("rd") | str("th") }
+      # The word naming a meeting in French. BIPM prints it lowercase; a
+      # consumer reference capitalizes it, as relaton's `Id::TYPES` does.
+      rule(:meeting_word_fr) { str("Réunion") | str("réunion") }
+
+      # --- committee documents ---
+      # The trailing "(YYYY)" date is optional (`.maybe`) so a partial reference
+      # that omits it — e.g. "CCTF REC 2" — still parses, leaving :year absent.
+      rule(:committee_short) do
+        (group >> space >> type_abbrev >>
+          (space >> number).maybe >> (space >> year_paren).maybe)
+          .as(:committee_short)
+      end
+      rule(:committee_long_en) do
+        (group >> space >> type_name_en >>
+          (space >> number).maybe >> (space >> year_paren_nolang).maybe)
+          .as(:committee_long_en)
+      end
+      rule(:committee_long_fr) do
+        (type_name_fr >> (space >> number).maybe >> space >>
+          connective >> space >> group >> (space >> year_paren_nolang).maybe)
+          .as(:committee_long_fr)
+      end
+      # Loose consumer form: a French type name in the English (group-leading)
+      # word order, e.g. "CIPM Décision 101-1 (2012)". BIPM never prints this,
+      # so it renders back as the canonical "Décision 101-1 du CIPM (2012)".
+      # Tried after `committee_long_en`, which is what keeps the words both
+      # languages share ("Action", "Statement") English.
+      rule(:committee_group_fr) do
+        (group >> space >> type_name_fr >>
+          (space >> number).maybe >> (space >> year_paren_nolang).maybe)
+          .as(:committee_long_fr)
+      end
+
+      # Bare MRA-interpretation form: a group directly followed by a document
+      # number with no type word (e.g. "CIPM 2005-06"). Tried last, so typed
+      # committee documents and meetings always win; only fires when a digit
+      # follows the group and the string is fully consumed.
+      rule(:committee_bare) do
+        (group >> space >> number >> (space >> year_paren).maybe)
+          .as(:committee_bare)
+      end
+
+      # --- meetings ---
+      # Canonical: "<group> <n><ordinal> Meeting [(YYYY)]". The second branch is
+      # the loose consumer word order "<group> Meeting <n>", which relaton's
+      # bespoke grammar accepts; both build the same tree, so the loose form
+      # renders back in the canonical spelling.
+      rule(:meeting_en) do
+        ((group >> space >> number >> ordinal >> space >> str("Meeting") >>
+          (space >> year_paren).maybe) |
+         (group >> space >> str("Meeting") >> space >> number >>
+           (space >> year_paren).maybe)).as(:meeting_en)
+      end
+      # Canonical: "<group> <n><sup>e</sup> réunion [(YYYY)]". The second and
+      # third branches are the loose consumer spellings — the plain "e" ordinal
+      # and the "<group> Réunion <n>" word order.
+      rule(:meeting_fr) do
+        ((group >> space >> number >> str("<sup>e</sup>") >> space >>
+          str("réunion") >> (space >> year_paren).maybe) |
+         (group >> space >> number >> str("e") >> space >> meeting_word_fr >>
+           (space >> year_paren).maybe) |
+         (group >> space >> meeting_word_fr >> space >> number >>
+           (space >> year_paren).maybe)).as(:meeting_fr)
+      end
+
+      # --- Metrologia journal ---
+      rule(:metrologia) do
+        (str("Metrologia") >>
+          (space >> digits.as(:volume) >>
+            (space >> alnum.as(:issue) >>
+              (space >> alnum.as(:article)).maybe).maybe).maybe).as(:metrologia)
+      end
+
+      # --- SI Brochure ---
+      rule(:edition) { (digits >> str("e")).as(:edition) }
+      rule(:version) { (str("v") >> match["0-9."].repeat(1)).as(:version) }
+      rule(:years) { (digits >> (str("/") >> digits).maybe).as(:years) }
+      # The "BIPM " prefix is optional, as it is on the variant and section
+      # rules: `si-brochure.yaml` stores the docnumber WITHOUT it, and
+      # `Relaton::Bipm::Bibliography.search` strips a leading "BIPM " before it
+      # ever reaches pubid. Either spelling renders back with the prefix.
+      rule(:si_brochure) do
+        ((str("BIPM SI Brochure") | str("SI Brochure")) >> space >>
+          (str("sur le SI") >> space).maybe >>
+          edition >> space >> version >> space >>
+          str("(") >> years >> str(", ") >> lang >> str(")")).as(:si_brochure)
+      end
+
+      # --- SI Brochure appendices / derived products ---
+      # The full primary-docidentifier content the relaton crawler indexes by,
+      # e.g. "BIPM SI Brochure Appendix 3" / "…Concise" / "…FAQ". The bare
+      # "SI Brochure Appendix 3" docnumber form is accepted too (rendered back
+      # with the "BIPM " prefix, matching the base SI Brochure record).
+      rule(:brochure_variant) do
+        ((str("Appendix") >> space >> digits) | str("Concise") | str("FAQ"))
+          .as(:variant)
+      end
+      rule(:si_brochure_variant) do
+        ((str("BIPM SI Brochure") | str("SI Brochure")) >> space >>
+          brochure_variant).as(:si_brochure_variant)
+      end
+
+      # Bare and sectioned SI Brochure references: "SI Brochure",
+      # "SI Brochure Part 1". Neither names an edition, so both are partial
+      # references whose `number` stays nil and which wildcard every edition —
+      # the same reading a date-less "CCTF REC 2" gets. "Part N" points at a
+      # section INSIDE the brochure, not a separate record, so it rides in the
+      # shared `part` attribute and stays out of the index key, exactly as the
+      # MEP/guide "Part N.M" tail does. Listed after the edition and variant
+      # rules for readability, not for correctness: Parslet threads
+      # `consume_all` down through an alternation, so an alternative that
+      # matches only a PREFIX ("SI Brochure" of "SI Brochure Concise") counts
+      # as a failure and the next one is tried whatever the order. Order only
+      # decides between two alternatives that BOTH consume the whole input.
+      rule(:si_brochure_section) do
+        ((str("BIPM SI Brochure") | str("SI Brochure")) >>
+          (space >> str("Part") >> space >> digits.as(:part)).maybe)
+          .as(:si_brochure_section)
+      end
+
+      # Shared "Appendix N [Annex N] Part N[.M]" tail carried by the full
+      # docidentifier content of MEPs and CC guides (the "Appendix 2 Part 1.1"
+      # or "Appendix 2 Annex 2 Part 1" suffix on "BIPM SI MEP …" etc.).
+      rule(:appendix_part) do
+        str("Appendix") >> space >> digits.as(:appendix) >>
+          (space >> str("Annex") >> space >> digits.as(:annex)).maybe >>
+          space >> str("Part") >> space >>
+          (digits >> (str(".") >> digits).maybe).as(:part)
+      end
+
+      # --- Mises en pratique (MEP) ---
+      # Two index-relevant spellings: the short docnumber ("SI MEP S1",
+      # "Rapport BIPM-2019/05") and the full "BIPM …" primary-docidentifier
+      # content the crawler actually keys on ("BIPM SI MEP S1 Appendix 2 Part
+      # 1.1"). The renderer reproduces whichever the identifier carries.
+      rule(:mep_code) { match["0-9A-Za-z"].repeat(1).as(:mep_code) }
+      rule(:report_code) do
+        (str("BIPM-") >> digits >> str("/") >> digits).as(:report_code)
+      end
+      rule(:mep_body) do
+        (str("SI MEP") >> space >> mep_code) |
+          (str("Rapport") >> space >> report_code)
+      end
+      rule(:mep) do
+        ((str("BIPM") >> space >> mep_body >> space >> appendix_part) |
+          mep_body).as(:mep)
+      end
+
+      # --- Consultative-Committee guides ---
+      # "<committee>-GD-<kind>-<number>" (e.g. "CCL-GD-MeP-1"), and its full
+      # "BIPM … Appendix 2 Part 2.2" content form. <kind> is "MeP" (mise en
+      # pratique) or "RSI" (réalisation du SI). Reuses the shared `group`
+      # (committee) and `number` (trailing sequence).
+      rule(:guide_kind) { (str("MeP") | str("RSI")).as(:guide_kind) }
+      rule(:guide_body) do
+        group >> str("-GD-") >> guide_kind >> str("-") >> digits.as(:number)
+      end
+      rule(:guide) do
+        ((str("BIPM") >> space >> guide_body >> space >> appendix_part) |
+          guide_body).as(:guide)
+      end
+
+      # After a leading group token, the shape after the first space decides:
+      # a digit → meeting; a type word → committee.
+      rule(:group_leading) do
+        meeting_en | meeting_fr | committee_short | committee_long_en |
+          committee_group_fr | committee_bare
+      end
+
+      rule(:identifier) do
+        metrologia | si_brochure | si_brochure_variant | si_brochure_section |
+          mep | guide | committee_long_fr | group_leading
+      end
+
+      root(:identifier)
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/bipm/renderer.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    # Human-readable renderer for the four BIPM identifier families. Registered
+    # as the `:human` format and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        case @id
+        when Identifiers::CommitteeDocument then render_committee(@id)
+        when Identifiers::Meeting then render_meeting(@id)
+        when Identifiers::MetrologiaArticle then render_metrologia(@id)
+        when Identifiers::SiBrochure then render_si_brochure(@id)
+        when Identifiers::Mep then render_mep(@id)
+        when Identifiers::Guide then render_guide(@id)
+        else
+          raise "Cannot render BIPM identifier: #{@id.class}"
+        end
+      end
+
+      private
+
+      # Optional " <number>" segment (with a leading space), or "" when absent.
+      def number_segment(id)
+        id.number ? " #{id.number}" : ""
+      end
+
+      # Optional " (<year>[, <lang>])" segment (with a leading space), or ""
+      # when the year is absent (a partial reference). `lang` is the trailing
+      # ", E"/", F" suffix carried only by the short committee form.
+      def year_segment(id, lang: "")
+        id.year ? " (#{id.year}#{lang})" : ""
+      end
+
+      def render_committee(id)
+        return render_committee_long(id) if id.long?
+
+        # short abbreviated key form. The type word is optional — the bare MRA
+        # form (e.g. "CIPM 2005-06") has no type_code, so omit it (and its
+        # leading space) rather than emit a double space.
+        lang = id.language ? ", #{id.language}" : ""
+        type = id.type_code ? " #{id.type_code}" : ""
+        "#{id.group}#{type}#{number_segment(id)}" \
+          "#{year_segment(id, lang: lang)}"
+      end
+
+      def render_committee_long(id)
+        if id.language == "F"
+          name = Identifier::TYPE_NAME_FR[id.type_code]
+          conn = Identifier.french_connective(id.group)
+          "#{name}#{number_segment(id)} #{conn} #{id.group}#{year_segment(id)}"
+        else
+          name = Identifier::TYPE_NAME_EN[id.type_code]
+          "#{id.group} #{name}#{number_segment(id)}#{year_segment(id)}"
+        end
+      end
+
+      def render_meeting(id)
+        if id.language == "F"
+          "#{id.group} #{id.number}<sup>e</sup> réunion#{year_segment(id)}"
+        else
+          "#{id.group} #{id.ordinal_en} Meeting#{year_segment(id)}"
+        end
+      end
+
+      def render_metrologia(id)
+        result = +"Metrologia"
+        result << " #{id.volume}" if id.volume
+        result << " #{id.issue}" if id.issue
+        result << " #{id.article}" if id.article
+        result
+      end
+
+      def render_si_brochure(id)
+        # Appendix / derived-product form indexed by relaton, keyed on the full
+        # "BIPM SI Brochure …" primary docidentifier content.
+        return "BIPM SI Brochure #{id.variant}" if id.variant
+        # Bare or sectioned reference: no edition means no version and no year
+        # to print either — just the brochure, optionally down to one part.
+        return "BIPM SI Brochure#{part_segment(id)}" unless id.edition
+
+        phrase = id.language == "F" ? "sur le SI " : ""
+        lang = id.language ? ", #{id.language}" : ""
+        "BIPM SI Brochure #{phrase}#{id.edition} #{id.version} " \
+          "(#{id.years}#{lang})"
+      end
+
+      # Optional " Part <n>" segment of an SI Brochure section reference.
+      def part_segment(id)
+        id.part ? " Part #{id.part}" : ""
+      end
+
+      # MEP: short docnumber ("SI MEP <code>" / "Rapport BIPM-YYYY/NN"), or the
+      # full "BIPM … Appendix N [Annex N] Part N.M" content the crawler keys on.
+      def render_mep(id)
+        body = id.report_code ? "Rapport #{id.report_code}" : "SI MEP #{id.mep_code}"
+        render_full_content(id, body)
+      end
+
+      # CC guide: short "<committee>-GD-<kind>-<number>", or its full
+      # "BIPM … Appendix N Part N.M" content form.
+      def render_guide(id)
+        body = "#{id.group}-GD-#{id.guide_kind}-#{id.number}"
+        render_full_content(id, body)
+      end
+
+      # Wrap a short body in the "BIPM … Appendix N [Annex N] Part N.M" content
+      # form when the identifier carries the appendix/part tail; otherwise emit
+      # the bare short body. `part` presence is what distinguishes the two.
+      def render_full_content(id, body)
+        return body unless id.part
+
+        annex = id.annex ? " Annex #{id.annex}" : ""
+        "BIPM #{body} Appendix #{id.appendix}#{annex} Part #{id.part}"
+      end
+    end
+  end
+end

data/lib/pubid/bipm/urn_generator.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    # Emits a URN carrying the canonical (language/form-neutral) document
+    # identity for each family:
+    #   committee:  urn:bipm:<group>:<type>:<number>:<year>   (empty number seg
+    #                                                          when number-less)
+    #   meeting:    urn:bipm:<group>:meeting:<number>:<year>
+    #   metrologia: urn:bipm:metrologia:<vol>[:<issue>[:<article>]]
+    #   brochure:   urn:bipm:si-brochure:<lang>:<edition>:<version>:<years>
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        case identifier
+        when Identifiers::CommitteeDocument then committee
+        when Identifiers::Meeting then meeting
+        when Identifiers::MetrologiaArticle then metrologia
+        when Identifiers::SiBrochure then si_brochure
+        else
+          raise "Cannot build URN for BIPM identifier: #{identifier.class}"
+        end
+      end
+
+      private
+
+      def committee
+        id = identifier
+        # type_code is nil for the bare MRA form → empty type segment, mirroring
+        # the empty-number-segment convention for number-less documents.
+        parts = ["urn", "bipm", id.group.downcase,
+                 id.type_code.to_s.downcase, id.number.to_s]
+        # A partial (date-less) reference drops the trailing year segment; a
+        # number-less-but-dated doc keeps its empty number segment.
+        parts << id.year if id.year
+        parts.join(":")
+      end
+
+      def meeting
+        id = identifier
+        parts = ["urn", "bipm", id.group.downcase, "meeting", id.number.to_s]
+        parts << id.year if id.year
+        parts.join(":")
+      end
+
+      def metrologia
+        parts = ["urn", "bipm", "metrologia", identifier.volume]
+        parts << identifier.issue if identifier.issue
+        parts << identifier.article if identifier.article
+        parts.join(":")
+      end
+
+      def si_brochure
+        ["urn", "bipm", "si-brochure", identifier.language.to_s.downcase,
+         identifier.edition, identifier.version, identifier.years].join(":")
+      end
+    end
+  end
+end

data/lib/pubid/bipm/urn_parser.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    # Inverts {UrnGenerator}, rebuilding the identifier directly from the URN
+    # fields (rather than reconstructing a printed string) because the printed
+    # forms carry surface detail — meeting ordinals, French wording — that the
+    # canonical URN intentionally omits.
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = body.split(":", -1)
+
+        case parts.first
+        when "metrologia" then build_metrologia(parts)
+        when "si-brochure" then build_si_brochure(parts)
+        else build_group_leading(parts)
+        end
+      end
+
+      private
+
+      def build_group_leading(parts)
+        group = parts[0].upcase
+        if parts[1] == "meeting"
+          Identifiers::Meeting.new(
+            group: group, number: parts[2].to_s, year: parts[3]&.to_i,
+          )
+        else
+          Identifiers::CommitteeDocument.new(
+            group: group,
+            type_code: (parts[1].empty? ? nil : parts[1].upcase),
+            number: (parts[2].empty? ? nil : parts[2]), year: parts[3]&.to_i
+          )
+        end
+      end
+
+      # `number` is the relaton index key and is derived, not printed, so it has
+      # to be set here exactly as `Builder` sets it — a URN-reconstructed
+      # identifier must agree with a parsed one attribute for attribute.
+      def build_metrologia(parts)
+        Identifiers::MetrologiaArticle.new(
+          number: presence(parts[1]), issue: parts[2], article: parts[3],
+        )
+      end
+
+      def build_si_brochure(parts)
+        Identifiers::SiBrochure.new(
+          number: presence(parts[2]), language: parts[1].to_s.upcase,
+          edition: parts[2], version: parts[3], years: parts[4]
+        )
+      end
+
+      # A URN segment that was never filled in is an empty string, not nil.
+      def presence(segment)
+        segment unless segment.nil? || segment.empty?
+      end
+    end
+  end
+end

data/lib/pubid/bipm.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bipm
+    extend Pubid::PrefixesSupport
+
+    # Leading tokens a printed BIPM identifier can start with: the 13 committee
+    # acronyms, "Metrologia" (journal), and "BIPM" (the SI Brochure). JCGM is
+    # deliberately excluded — it is owned by the separate Pubid::Jcgm flavor,
+    # so BIPM never emits pubid:jcgm:* rows. French full-name forms that lead
+    # with a type word ("Recommandation 1 du CCL …") are omitted per the
+    # "exclude ambiguous tokens" policy.
+    PREFIXES = %w[
+      BIPM Metrologia
+      CIPM CGPM JCRB CCTF CCQM CCT CCL CCAUV CCU CCM CCEM CCPR CCRI
+    ].freeze
+
+    autoload :Builder, "#{__dir__}/bipm/builder"
+    autoload :Identifier, "#{__dir__}/bipm/identifier"
+    autoload :Identifiers, "#{__dir__}/bipm/identifiers"
+    autoload :Parser, "#{__dir__}/bipm/parser"
+    autoload :Renderer, "#{__dir__}/bipm/renderer"
+    autoload :UrnGenerator, "#{__dir__}/bipm/urn_generator"
+    autoload :UrnParser, "#{__dir__}/bipm/urn_parser"
+
+    # Parse a BIPM identifier string into an identifier object.
+    # @param identifier [String] the printed identifier
+    # @return [Identifier] the parsed identifier
+    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 Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Bipm::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants.filter_map do |const|
+        klass = Identifiers.const_get(const)
+        klass if klass.is_a?(Class) &&
+          klass.singleton_methods(false).include?(:type) &&
+          klass.type.is_a?(Hash)
+      rescue NameError
+        nil
+      end
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    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] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find do |s|
+        s.abbr.any? { |a| a.to_s.upcase == abbr_str }
+      end
+    end
+  end
+end
+
+# Register BIPM flavor with the registry
+Pubid::Registry.register(:bipm, Pubid::Bipm)