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

data/lib/pubid/bipm/builder.rb

@@ -30,6 +30,8 @@ module Pubid
           build_si_brochure(data[:si_brochure])
         elsif data[:si_brochure_variant]
           build_si_brochure_variant(data[:si_brochure_variant])
+        elsif data.key?(:si_brochure_section)
+          build_si_brochure_section(data[:si_brochure_section])
         elsif data[:mep]
           build_mep(data[:mep])
         elsif data[:guide]
@@ -41,61 +43,115 @@ module Pubid
 
       private
 
+      # `group` and `language` are normalized here, so a historic committee
+      # name (CCDS) and a two-letter language code (EN/FR) never reach an
+      # attribute — the index stores only the current name and the one-letter
+      # code BIPM prints.
       def build_committee(node, form:, language: nil)
         Identifiers::CommitteeDocument.new(
-          group: node[:group].to_s,
+          group: Identifier.normalize_group(node[:group]),
           type_code: Identifier::TYPE_WORD_TO_CODE[node[:type_word].to_s],
           number: node[:number]&.to_s,
           year: node[:year]&.to_s&.to_i,
-          language: language || node[:language]&.to_s,
+          language: Identifier.normalize_language(language || node[:language]),
           form: form,
         )
       end
 
       def build_meeting(node, language: nil)
         Identifiers::Meeting.new(
-          group: node[:group].to_s,
+          group: Identifier.normalize_group(node[:group]),
           number: node[:number].to_s,
           year: node[:year]&.to_s&.to_i,
-          language: language || node[:language]&.to_s,
+          language: Identifier.normalize_language(language || node[:language]),
         )
       end
 
+      # `number` is the volume, so every article of a volume clusters into one
+      # relaton-index bucket (the IETF draft-slug / IANA registry-slug
+      # convention). It is nil only for the journal-level record, which carries
+      # no volume at all.
+      #
+      # It is deliberately redundant with `volume`, which stays because the
+      # renderer and the URN generator read it. Two limits of that redundancy,
+      # both accepted rather than engineered around (see the note above
+      # NUMBER_SOURCE_ATTRIBUTES in identifier.rb for the half that IS
+      # handled):
+      #
+      #   * THE BUILDER IS THE CONSTRUCTOR OF RECORD. A caller that bypasses it
+      #     — `MetrologiaArticle.new(volume: 51, …)` — gets a nil `number` and
+      #     so an empty index key. Deriving it in `initialize` instead would
+      #     cover that, but `#exclude` rebuilds through `self.class.new`, so it
+      #     would also silently re-fill a `number` the caller just excluded.
+      #   * NO SELF-HEALING ACROSS from_hash. lutaml assigns attributes AFTER
+      #     `initialize`, so a legacy pre-`number` index row (one carrying only
+      #     `volume`) deserializes with `number` nil and no error at all —
+      #     lutaml ignores unknown keys and relaton's `id_supported?` skips its
+      #     round-trip check for concrete subclasses, which every BIPM id is.
+      #     relaton-data-bipm must regenerate index-v2 to gain the key. This is
+      #     weaker than the IEEE `CodeNumber` mixin, which rebuilds `code_obj`
+      #     from its split columns after `from_hash`.
       def build_metrologia(node)
         node = {} unless node.is_a?(Hash)
         Identifiers::MetrologiaArticle.new(
-          volume: node[:volume]&.to_s&.to_i,
+          number: node[:volume]&.to_s,
           issue: node[:issue]&.to_s,
           article: node[:article]&.to_s,
         )
       end
 
+      # The SI Brochure has no document number of its own, so the edition is
+      # the index key — it clusters the English and French records of one
+      # edition. The grammar makes `edition` mandatory here, so it is never nil.
       def build_si_brochure(node)
         Identifiers::SiBrochure.new(
+          number: node[:edition].to_s,
           edition: node[:edition].to_s,
           version: node[:version].to_s,
           years: node[:years].to_s,
-          language: node[:language]&.to_s,
+          language: Identifier.normalize_language(node[:language]),
         )
       end
 
+      # The derived products (Appendix N, Concise, FAQ) carry no edition, so
+      # the variant name is their key. The grammar makes it mandatory here.
       def build_si_brochure_variant(node)
-        Identifiers::SiBrochure.new(variant: node[:variant].to_s)
+        variant = node[:variant].to_s
+        Identifiers::SiBrochure.new(number: variant, variant: variant)
       end
 
+      # A bare or sectioned reference names no edition, so it gets no key: it is
+      # a partial reference that wildcards every edition. The bare form captures
+      # nothing, so the parser hands back a slice rather than a hash.
+      def build_si_brochure_section(node)
+        node = {} unless node.is_a?(Hash)
+        Identifiers::SiBrochure.new(part: node[:part]&.to_s)
+      end
+
+      # The Appendix/Annex/Part tail is the full-content spelling of the SAME
+      # document, so it stays out of the key.
       def build_mep(node)
         Identifiers::Mep.new(
-          mep_code: node[:mep_code]&.to_s,
-          report_code: node[:report_code]&.to_s,
+          **mep_codes(node),
           appendix: node[:appendix]&.to_s,
           annex: node[:annex]&.to_s,
           part: node[:part]&.to_s,
         )
       end
 
+      # A MEP is identified by its unit code, or by the report code for the
+      # `Rapport BIPM-YYYY/NN` variant; exactly one of the two is set, and
+      # whichever it is becomes the relaton index key.
+      def mep_codes(node)
+        mep_code = node[:mep_code]&.to_s
+        report_code = node[:report_code]&.to_s
+        { number: mep_code || report_code, mep_code: mep_code,
+          report_code: report_code }
+      end
+
       def build_guide(node)
         Identifiers::Guide.new(
-          group: node[:group].to_s,
+          group: Identifier.normalize_group(node[:group]),
           guide_kind: node[:guide_kind].to_s,
           number: node[:number].to_s,
           appendix: node[:appendix]&.to_s,

data/lib/pubid/bipm/identifier.rb

@@ -19,6 +19,19 @@ module Pubid
         CIPM CGPM JCRB CCTF CCQM CCT CCL CCAUV CCU CCM CCEM CCPR CCRI
       ].freeze
 
+      # Historic committee names consumer references still use. BIPM renamed the
+      # CCDS (Comité Consultatif pour la Définition de la Seconde) to CCTF in
+      # 1997 and the index keys the current name, so an alias is resolved at
+      # parse time and never stored. Extend the map, not the parser, to add one.
+      GROUP_ALIASES = { "CCDS" => "CCTF" }.freeze
+
+      # Every group token the grammar accepts, current names and aliases alike.
+      PARSEABLE_GROUPS = (GROUPS + GROUP_ALIASES.keys).freeze
+
+      # Two-letter codes consumer references use for the one-letter language
+      # codes BIPM prints. Resolved at parse time, so only "E"/"F" is stored.
+      LANGUAGE_ALIASES = { "EN" => "E", "FR" => "F" }.freeze
+
       # Committee document type codes and their printed long-form names. Note
       # DECL prints as "Statement" in BOTH languages in the source data.
       TYPE_CODES = %w[REC RES DECN ACT DECL].freeze
@@ -30,12 +43,20 @@ module Pubid
         "REC" => "Recommandation", "RES" => "Résolution",
         "DECN" => "Décision", "ACT" => "Action", "DECL" => "Statement"
       }.freeze
-      # Every printed type word (abbrev + English + French) → canonical code.
+      # Printed type words that are not the canonical name of their code. BIPM
+      # prints DECL as "Statement" in both languages, but a reference spells the
+      # word out; without these the parser matched "Declaration" and then mapped
+      # it to NO code, so the renderer emitted a corrupt "CGPM  1 (1971)".
+      TYPE_WORD_ALIASES = {
+        "Declaration" => "DECL", "Déclaration" => "DECL"
+      }.freeze
+
+      # Every printed type word (abbrev + English + French + alias) → code.
       TYPE_WORD_TO_CODE = TYPE_CODES.each_with_object({}) do |code, map|
         map[code] = code
         map[TYPE_NAME_EN[code]] = code
         map[TYPE_NAME_FR[code]] = code
-      end.freeze
+      end.merge(TYPE_WORD_ALIASES).freeze
 
       # Shared attributes (flat). Booleans/strings carry no default so they stay
       # nil and drop from the serialized hash unless set.
@@ -48,8 +69,9 @@ module Pubid
       # "long" (full type-word name). Defaults to "short" so it drops from the
       # canonical hash for the indexed primary form.
       attribute :form, :string, default: "short"
-      # Metrologia journal fields.
-      attribute :volume, :integer
+      # Metrologia journal fields. `volume` is NOT stored — it is exactly the
+      # index key, so MetrologiaArticle derives it from `number` (the IANA
+      # `registry` / IETF `series` pattern) rather than serializing both.
       attribute :issue, :string # may be alphanumeric ("1A")
       attribute :article, :string
       # SI Brochure fields.
@@ -69,6 +91,17 @@ module Pubid
       attribute :annex, :string
       attribute :part, :string
 
+      # Attributes `Builder` derives `number` from for the families that have no
+      # document number of their own. Excluding one of these has to clear
+      # `number` too, or a wildcarded identifier would keep a stale index key —
+      # the "reset the WHOLE cluster, not just the scalar" lesson CLAUDE.md
+      # records for CSA's year and IEEE's year/month/day. `:volume` is listed
+      # even though it is no longer an attribute: the base loop skips it, but
+      # `exclude(:volume)` must still clear the key it derives from.
+      NUMBER_SOURCE_ATTRIBUTES = %i[
+        volume edition variant mep_code report_code
+      ].freeze
+
       # Polymorphic type map for lutaml::Model key_value (de)serialization:
       # maps each subclass's polymorphic_name to its class name so a stored hash
       # rebuilds the correct identifier type via from_hash.
@@ -91,7 +124,6 @@ module Pubid
         map "year", to: :year
         map "language", to: :language
         map "form", to: :form
-        map "volume", to: :volume
         map "issue", to: :issue
         map "article", to: :article
         map "edition", to: :edition
@@ -117,6 +149,20 @@ module Pubid
         group == "CGPM" ? "de la" : "du"
       end
 
+      # Resolve a historic committee name to the name the index keys.
+      def self.normalize_group(token)
+        name = token.to_s
+        GROUP_ALIASES.fetch(name, name)
+      end
+
+      # Resolve a two-letter language code to the one-letter code BIPM prints.
+      def self.normalize_language(token)
+        return nil if token.nil?
+
+        code = token.to_s
+        LANGUAGE_ALIASES.fetch(code, code)
+      end
+
       def long?
         form == "long"
       end
@@ -130,6 +176,7 @@ module Pubid
       def exclude(*args)
         result = super
         result.year = nil if args.include?(:year) || args.include?(:date)
+        result.number = nil if args.intersect?(NUMBER_SOURCE_ATTRIBUTES)
         result
       end
 
@@ -138,13 +185,93 @@ module Pubid
         render(format: :human, **opts)
       end
 
+      # --- MR string / slug -------------------------------------------------
+      #
+      # `to_slug` is what consumers use as an output FILENAME, so every BIPM
+      # identifier needs a non-empty, filename-safe, non-colliding MR. None of
+      # the base ::Pubid::Identifier hooks work here unchanged, because BIPM
+      # models each of them with its own flat attribute rather than the shared
+      # component the base expects. Each override below says which.
+      #
+      # The number segment and the family discriminator are supplied per leaf
+      # (`mr_number_with_part` / `mr_type`), because BIPM's six families share
+      # no numbering.
+      #
+      # Three deliberate collapses — MR is a canonical DOCUMENT slug, so
+      # alternate print spellings of one document share it (the URN already
+      # collapses the first two): `form` (short vs long committee spelling) and
+      # the MEP/Guide `appendix`/`annex`/`part` full-content tail are omitted,
+      # while `language` is kept because the E and F records are distinct
+      # documents upstream.
+
+      # BIPM keeps its publisher in the PUBLISHER constant rather than the
+      # inherited `publisher` attribute (which would fail type validation), so
+      # the base hook — `publisher&.to_s` — is nil. The JIS/IANA shape.
+      def mr_publisher
+        PUBLISHER.downcase
+      end
+
+      # BIPM stores the publication year in its own :integer attribute rather
+      # than a Components::Date, so the base hook reads an unset `date`.
+      def mr_year
+        year&.to_s
+      end
+
+      # BIPM's `edition` is a plain :string ("9e"), not a Components::Edition,
+      # so the base hook's `edition.number` raises NoMethodError. SiBrochure
+      # folds the edition into its own number segment instead.
+      def mr_edition
+        nil
+      end
+
+      # BIPM has a single `language` string, not the base's `languages`
+      # collection.
+      def mr_languages
+        language&.to_s&.downcase
+      end
+
+      # BIPM uses its own `type_code` attribute rather than a typed_stage, so
+      # the base hook is always nil; the leaves supply the discriminator.
+      def mr_type
+        nil
+      end
+
+      # Join the parts of a number segment into one filename-safe token.
+      #
+      # The sanitisation is by CHARSET, not an enumerated escape list, so a
+      # field added later cannot leak an unsafe character: everything outside
+      # [a-z0-9] collapses to `-`. BIPM needs at least three of those today —
+      # a `/` (the MEP report code "BIPM-2019/05"), a space (the SI Brochure
+      # variant "Appendix 3") and a `.` (the brochure version "v3.01"). The
+      # dot matters beyond filename safety: Renderers::MrString joins SEGMENTS
+      # with ".", so a dot inside one would break the documented segment
+      # structure.
+      #
+      # Caveat: `-` is both the intra-segment join and a substitute, so two
+      # different field splits could in principle produce one slug. That
+      # cannot happen with today's grammar — none of `group`, `guide_kind`,
+      # `mep_code`, `issue` or `article` admits a `-`, and `number`'s own
+      # internal `-` ("10-1") is unambiguous because the `group` before it
+      # cannot contain one. A future hyphen-bearing free-text field would
+      # need a different join.
+      def mr_slug(*parts)
+        slug = parts.compact.map(&:to_s).reject(&:empty?).join("-").downcase
+        slug = slug.gsub(/[^a-z0-9]+/, "-").gsub(/\A-+|-+\z/, "")
+        slug unless slug.empty?
+      end
+
       # Parse a BIPM identifier string into an identifier object.
       # @param identifier [String] the BIPM identifier string
       # @return [Identifier] the appropriate identifier object
-      # @raise [RuntimeError] if parsing fails
+      # @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
 
         # Normalize legacy/docnumber-style spellings before parsing
@@ -152,8 +279,6 @@ module Pubid
         normalized = Core::UpdateCodes.apply(identifier, :bipm)
         parsed = Parser.parse(normalized)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse BIPM identifier '#{identifier}': #{e.message}"
       end
     end
   end

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

@@ -18,6 +18,18 @@ module Pubid
           { key: :committee_document, web: :committee_document,
             title: "Committee Document", short: "committee-document" }
         end
+
+        # MR: `bipm.<type>.<group>-<number>.<year>[.<lang>]`. The type code
+        # discriminates REC/RES/DECN/ACT/DECL; the bare CIPM MRA form has none.
+        def mr_type
+          type_code&.downcase
+        end
+
+        # The group has to be in the number segment or `CCTF REC 2` and
+        # `CCEM REC 2` would share a slug.
+        def mr_number_with_part
+          mr_slug(group, number)
+        end
       end
     end
   end

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

@@ -18,6 +18,17 @@ module Pubid
         def self.type
           { key: :guide, web: :guide, title: "Guide", short: "guide" }
         end
+
+        # MR: `bipm.guide.<group>-<kind>-<number>`. Both the committee and the
+        # kind are needed — the trailing sequence restarts per committee, so
+        # `CCL-GD-MeP-1` and `CCEM-GD-RSI-1` both carry number "1".
+        def mr_type
+          "guide"
+        end
+
+        def mr_number_with_part
+          mr_slug(group, guide_kind, number)
+        end
       end
     end
   end

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

@@ -35,6 +35,18 @@ module Pubid
         def ordinal_en
           "#{number}#{self.class.ordinal_suffix(number)}"
         end
+
+        # MR: `bipm.meeting.<group>-<number>.<year>`. The English and French
+        # spellings of one meeting collapse onto the same slug on purpose.
+        def mr_type
+          "meeting"
+        end
+
+        # The group has to be in the number segment or the 17th CGPM and the
+        # 17th CIPM meeting would share a slug.
+        def mr_number_with_part
+          mr_slug(group, number)
+        end
       end
     end
   end

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

@@ -15,6 +15,18 @@ module Pubid
         def self.type
           { key: :mep, web: :mep, title: "Mise en pratique", short: "mep" }
         end
+
+        # MR: `bipm.mep.<code>`. Exactly one of `mep_code` / `report_code` is
+        # set; the report code carries a `/` that `mr_slug` sanitises away. The
+        # full-content "Appendix 2 Part x" tail is the same document, so it
+        # stays out of the slug.
+        def mr_type
+          "mep"
+        end
+
+        def mr_number_with_part
+          mr_slug(mep_code || report_code)
+        end
       end
     end
   end

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

@@ -18,6 +18,30 @@ module Pubid
           { key: :metrologia_article, web: :metrologia_article,
             title: "Metrologia Article", short: "metrologia-article" }
         end
+
+        # MR: `bipm.metrologia[.<volume>[-<issue>[-<article>]]]`.
+        # The volume IS the index key, so it is derived from `number` instead
+        # of being stored beside it — storing both would duplicate the same
+        # value in every one of the 6,204 published article rows. Kept as an
+        # Integer because that is the public type consumers already read
+        # (`Relaton::Bipm::Bibliography#id_hash` calls `pubid.volume`).
+        #
+        # Safe as a plain method only because `volume` is no longer a lutaml
+        # attribute anywhere in the hierarchy — a method that shadows a
+        # generated accessor corrupts attribute resolution (CLAUDE.md).
+        def volume
+          number&.to_i
+        end
+
+        def mr_type
+          "metrologia"
+        end
+
+        # `number` is only the volume (it is the CLUSTERING relaton-index key),
+        # so per-article distinctness has to come from here: the full triple.
+        def mr_number_with_part
+          mr_slug(volume, issue, article)
+        end
       end
     end
   end

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

@@ -14,6 +14,19 @@ module Pubid
           { 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

data/lib/pubid/bipm/parser.rb

@@ -11,7 +11,7 @@ module Pubid
     #
     # 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 < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # --- primitives ---
       rule(:space) { str(" ") }
       rule(:digits) { match["0-9"].repeat(1) }
@@ -21,7 +21,11 @@ module Pubid
         (digits >> (str("-") >> digits).repeat).as(:number)
       end
       rule(:year) { match["0-9"].repeat(4, 4).as(:year) }
-      rule(:lang) { match["EF"].as(:language) }
+      # "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(")")
@@ -34,7 +38,7 @@ module Pubid
         tokens.sort_by { |t| -t.length }.map { |t| str(t) }.reduce(:|)
       end
 
-      rule(:group) { alternation(Identifier::GROUPS).as(:group) }
+      rule(:group) { alternation(Identifier::PARSEABLE_GROUPS).as(:group) }
 
       rule(:type_abbrev) do
         alternation(Identifier::TYPE_CODES).as(:type_word)
@@ -49,6 +53,9 @@ module Pubid
       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
@@ -68,6 +75,17 @@ module Pubid
           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
@@ -78,13 +96,26 @@ module Pubid
       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).as(:meeting_en)
-      end
+        ((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).as(:meeting_fr)
+        ((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 ---
@@ -99,8 +130,12 @@ module Pubid
       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") >> space >>
+        ((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)
@@ -120,6 +155,24 @@ module Pubid
           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.).
@@ -166,12 +219,12 @@ module Pubid
       # a digit → meeting; a type word → committee.
       rule(:group_leading) do
         meeting_en | meeting_fr | committee_short | committee_long_en |
-          committee_bare
+          committee_group_fr | committee_bare
       end
 
       rule(:identifier) do
-        metrologia | si_brochure | si_brochure_variant | mep | guide |
-          committee_long_fr | group_leading
+        metrologia | si_brochure | si_brochure_variant | si_brochure_section |
+          mep | guide | committee_long_fr | group_leading
       end
 
       root(:identifier)

data/lib/pubid/bipm/renderer.rb

@@ -75,6 +75,9 @@ module Pubid
         # 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}" : ""
@@ -82,6 +85,11 @@ module Pubid
           "(#{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)