pubid 2.0.0.pre.alpha.12 → 2.0.0.pre.alpha.13

data/lib/pubid/asme/builder.rb

@@ -105,14 +105,18 @@ module Pubid
             # BPVC COMPLETE CODE BIND
             designator_str = "BPVC COMPLETE CODE BIND"
           elsif bpvc_data[:subdivision] && bpvc_data[:subdivision][:ssc_code]
-            # BPVC.SSC.XI.II.V.IX pattern
-            ssc_sections = bpvc_data[:subdivision][:ssc_sections]
-            sections_str = if ssc_sections.is_a?(Array)
-                             ssc_sections.join(".")
-                           else
-                             ssc_sections.to_s
-                           end
-            designator_str = "BPVC.SSC.#{sections_str}"
+            # BPVC.SSC.XI.II.V.IX pattern. The sections sit under `ssc_code`;
+            # reading them one level up rendered every SSC id as "BPVC.SSC.".
+            # A bare "BPVC.SSC." (the catalogue's series identity) parses
+            # with no inner capture, so `ssc_code` is the matched Slice.
+            ssc_code = bpvc_data[:subdivision][:ssc_code]
+            sections = ssc_code.is_a?(Hash) ? ssc_code[:ssc_sections] : nil
+            designator_str =
+              if sections.nil? || sections.to_s.empty?
+                "BPVC.SSC."
+              else
+                "BPVC.SSC.#{sections}"
+              end
           elsif bpvc_data[:subdivision] && bpvc_data[:subdivision][:case_code]
             # BPVC.CC.BPV or BPVC.CC.NC.XI - extract from subdivision hash
             cc = bpvc_data[:subdivision][:case_code].to_s
@@ -120,7 +124,8 @@ module Pubid
 
             designator_str = case_sub && !case_sub.empty? ? "BPVC.CC.#{cc}.#{case_sub}" : "BPVC.CC.#{cc}"
           elsif bpvc_data[:case_code]
-            # Dash notation: BPVC-CC-BPV
+            # Dash notation: BPVC-CC-BPV. Keep the dashes: the ASME catalogue
+            # lists BPVC-CC-BPV and BPVC.CC.BPV as two separate documents.
             cc = bpvc_data[:case_code].to_s
             designator_str = "BPVC-CC-#{cc}"
           elsif bpvc_data[:subdivision]
@@ -160,3 +165,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Asme::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/asme/components/code.rb

@@ -10,6 +10,8 @@ module Pubid
       # Stays independent of Pubid::Components::Code because ASME uses
       # +designator+ (a flavor-specific letter prefix) plus +number+.
       class Code < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :designator, :string
         attribute :number, :string
 

data/lib/pubid/asme/identifiers/standard.rb

@@ -83,10 +83,15 @@ module Pubid
         # enumerated escape list. The output emptiness check matters: a value
         # made only of out-of-charset characters collapses to "", which is
         # truthy in Ruby and would reach the renderer as a blank segment.
+        #
+        # A literal "-" is written "--", because "." and "-" otherwise meet:
+        # ASME sells BPVC-CC-BPV (the 2019 code-case supplements) and
+        # BPVC.CC.BPV (the code-case book) as different documents. "_" is not
+        # an option — the MR format reserves it for supplement layers.
         def mr_sanitize(value)
           return nil if value.nil? || value.to_s.empty?
 
-          sanitized = value.to_s.downcase
+          sanitized = value.to_s.downcase.gsub("-", "--")
             .gsub(/[^a-z0-9-]+/, "-").gsub(/\A-+|-+\z/, "")
           sanitized.empty? ? nil : sanitized
         end

data/lib/pubid/asme/parser.rb

@@ -45,11 +45,19 @@ module Pubid
             (
               dot >>
               (
-                # SSC with complex subdivision: BPVC.SSC.XI.II.V.IX
-                (str("SSC") >> (dot >> roman_numeral).repeat(1).as(:ssc_sections)).as(:ssc_code) |
-                # CC = Case Code: BPVC.CC.BPV or BPVC.CC.NC.XI
+                # SSC with complex subdivision: BPVC.SSC.XI.II.V.IX,
+                # or the bare catalogue form BPVC.SSC.
+                (str("SSC") >>
+                 (dot >>
+                  (roman_numeral >> (dot >> roman_numeral).repeat)
+                    .as(:ssc_sections)).maybe >>
+                 dot.maybe).as(:ssc_code) |
+                # CC = Case Code: BPVC.CC.BPV or BPVC.CC.NC.XI; the
+                # catalogue prints the sub-code with its own leading dot
+                # (BPVC.CC.BPV..I)
                 (str("CC") >> dot >> bpvc_letter_code.as(:case_code) >>
-                 (dot >> (roman_numeral | bpvc_letter_code)).maybe.as(:case_sub)) |
+                 (dot >> dot.maybe >>
+                  (roman_numeral | bpvc_letter_code).as(:case_sub)).maybe) |
                 # Standard roman numeral subdivision: BPVC.I or BPVC.III.1.NB
                 (roman_numeral.as(:section) >>
                  (dot >> (digits | bpvc_letter_code).as(:subsection)).maybe >>
@@ -94,7 +102,7 @@ module Pubid
 
       # Joint publisher patterns
       rule(:iso_asme_publisher) do
-        str("ISO/ASME").as(:joint_publisher) >> space
+        str("ISO/ASME").as(:joint_publisher) >> space.maybe
       end
 
       rule(:asme_ans_publisher) do
@@ -104,13 +112,13 @@ module Pubid
       rule(:csa_asme_publisher) do
         csa_publisher.as(:first_publisher) >> space >>
           match("[A-Z0-9.]").repeat(1).as(:first_code) >>
-          slash >> asme_publisher.as(:second_publisher) >> space
+          space.maybe >> slash >> asme_publisher.as(:second_publisher) >> space
       end
 
       rule(:api_asme_publisher) do
         api_publisher.as(:first_publisher) >> space >>
           match("[0-9-]").repeat(1).as(:first_code) >>
-          slash >> asme_publisher.as(:second_publisher) >> space
+          space.maybe >> slash >> asme_publisher.as(:second_publisher) >> space
       end
 
       # Standard ASME publisher
@@ -129,6 +137,20 @@ module Pubid
         ).as(:designator)
       end
 
+      # A trailing edition year ("-2021", "-20XX") and nothing after it.
+      # `number_part` must not read it as a dash-separated number: a
+      # designator with no number ("BPVC.I-2021", "BPE-2012") then stored the
+      # year as its number, and the year itself was lost.
+      #
+      # The grammar cannot tell a year from a final 4-digit number: a code
+      # whose whole number is "-1234" would parse as year 1234. No ASME
+      # corpus id has that shape; spec/pubid/asme/root_number_spec.rb pins
+      # the choice.
+      rule(:trailing_year) do
+        dash >> (str("20XX") | str("202X") | (str("20") >> digit >> str("X")) |
+          digit.repeat(4, 4)) >> match("[0-9A-Z.]").absent?
+      end
+
       # Number part - can start with dot (NM.1), be dotted (16.5), OR dash-separated (BTH-1)
       rule(:number_part) do
         (
@@ -136,7 +158,7 @@ module Pubid
           (dot >> match("[0-9A-Z]").repeat(1) >>
            (dot >> match("[0-9A-Z]").repeat(1)).repeat) |
           # Dash-separated first (for BTH-1, CA-1 patterns)
-          (dash >> match("[0-9A-Z]").repeat(1) >>
+          (trailing_year.absent? >> dash >> match("[0-9A-Z]").repeat(1) >>
            (dot >> match("[0-9A-Z]").repeat(1)).repeat) |
           # Regular dotted numbers
           (match("[0-9A-Z]").repeat(1) >>
@@ -144,9 +166,11 @@ module Pubid
         ).as(:number)
       end
 
-      # PTC special: space-separated number with optional suffix
+      # PTC special: space-separated number with optional suffix; the
+      # renderer glues the designator to the number (PTC 19.3 TW and
+      # PTC19.3 TW are the same document)
       rule(:ptc_number) do
-        space >>
+        space.maybe >>
           (
             match("[0-9]").repeat(1) >>
             (dot >> match("[0-9]").repeat(1)).repeat
@@ -155,9 +179,10 @@ module Pubid
           (space >> letters.as(:ptc_suffix)).maybe
       end
 
-      # TR special: space-separated number (like "ASME TR A17.1-8.4-2013")
+      # TR special: space-separated number (like "ASME TR A17.1-8.4-2013");
+      # the rendered form glues the designator (TRA17.1-8.4)
       rule(:tr_number) do
-        space >>
+        space.maybe >>
           (
             match("[A-Z0-9]").repeat(1) >>
             (dot >> match("[0-9A-Z]").repeat(1)).repeat >>
@@ -250,10 +275,12 @@ module Pubid
           reaffirmation.maybe
       end
 
-      # Joint published identifier - ISO/ASME
+      # Joint published identifier - ISO/ASME. The catalogue also lists
+      # the numberless series identity "ISO/ASME-2015" beside the
+      # numbered adoptions.
       rule(:iso_asme_identifier) do
         iso_asme_publisher >>
-          number_part >>
+          number_part.maybe >>
           (dash >> (draft_year | year_4digit)).maybe >>
           language.maybe >>
           reaffirmation.maybe

data/lib/pubid/astm/CLAUDE.md

@@ -0,0 +1,9 @@
+# ASTM flavor notes
+
+ASTM index key and MR slug.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/astm/` or `spec/pubid/astm/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+## From the root note "AMCA / ASME / ASTM index key (`root.number`): three flavors, three different shapes"
+
+**(3) ASTM — the mixin, on EVERY concrete class.** `Astm::Components::Code` is a five-field taxonomy (`letter`/`number`/`suffix`/`subseries`/`dual_m`) that the renderer reads field-by-field, so it keeps its structure: `Identifiers::CodeNumber` installs the five columns plus a derived `#code`. **It is included by `Standard` AND by `IsoDualPublished`, which inherits `Standard` — deliberately, not redundantly**: a class that is itself inherited from must still declare the columns so its subclass holds its own snapshot rather than relying on a parent table. `Adjunct` has no code at all, so its designation IS its number: the `designation` attribute was **removed** and the value stored in `number` directly, because keeping both made `to_hash` emit the same string twice and a `def number` shadowing the attribute is the construct CLAUDE.md forbids.

data/lib/pubid/astm/builder.rb

@@ -164,3 +164,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Astm::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/astm/components/code.rb

@@ -11,6 +11,8 @@ module Pubid
       # rich taxonomy: +letter+ (A-G for standards), +suffix+ (A/B/C for
       # data series), +subseries+ (S1/S4/S10), and +dual_m+ (metric flag).
       class Code < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :letter, :string       # A-G for standards
         attribute :number, :string       # Main number
         attribute :suffix, :string       # A, B, C for data series

data/lib/pubid/astm/parser.rb

@@ -110,7 +110,10 @@ module Pubid
         digits.as(:number) >>
           (
             str("HOL").as(:hol_suffix) |
-            (data_series_suffix >> data_series_subseries_no_dash.maybe) |
+            # A letter suffix may carry its subseries with the dash
+            # spelled out too ("DS55S-S1"), not only glued ("DS55S1").
+            (data_series_suffix >>
+              (data_series_subseries_no_dash | data_series_subseries_with_dash).maybe) |
             data_series_subseries_with_dash
           ).maybe
       end

data/lib/pubid/bipm/CLAUDE.md

@@ -0,0 +1,11 @@
+# BIPM flavor notes
+
+BIPM update codes, index key, MR slug and loose consumer forms.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/bipm/` or `spec/pubid/bipm/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **BIPM `update_codes` + bare MRA form**: `Pubid::Bipm::Identifier.parse` (`lib/pubid/bipm/identifier.rb`) applies `Core::UpdateCodes.apply(identifier, :bipm)` **after** the ReDoS length guard, **before** `Parser.parse` — mirroring ccsds/plateau, and the single entry point (`lib/pubid/bipm.rb#self.parse` delegates here). `data/bipm/update_codes.yaml` normalizes the CIPM MRA:2005 interpretation doc's docnumber-style spellings (`CIPM/2005-06(REV)`, `CIPM 2005-06(REV)`) → the parseable `CIPM 2005-06`. That **bare `<GROUP> <number>` form (no type word)** is a first-class `Identifiers::CommitteeDocument` with **`type_code` nil**: the `committee_bare` parser rule (`group space number (year).maybe`) is placed **last** in `group_leading` so typed committee docs and meetings always win — it only fires on strings that fail every earlier rule and are fully consumed, so it never reroutes a valid form (it only newly-accepts previously-rejected `GROUP number` strings). The builder routes it through the existing `build_committee` (a bare node has no `type_word` → `TYPE_WORD_TO_CODE[""]` → nil `type_code`, never `""`), so `to_hash` drops the nil `type_code` and `root.number` is the non-empty document number (`"2005-06"`). The nil `type_code` is handled at every render site: the renderer omits the type segment (no double space), and the URN gen/parser use an **empty type segment** (`urn:bipm:cipm::2005-06`) symmetric with the documented empty-number-segment convention.
+
+- **BIPM index key (`root.number`) + MR slug**: relaton-index narrows on `id.root.number.to_s` (`Relaton::Index::Type#get_id_number` → `bsearch_left`/`bsearch_right`), and the same `number` feeds `to_mr_string`/`to_slug`, which consumers use as an output **filename**. `Pubid::Bipm::Builder` used to set `number` only in `build_committee`/`build_meeting`/`build_guide`, so **6,213 of the 7,922 published `relaton-data-bipm` index-v2 rows (78%) shared the empty key `""`** and the binary search silently degenerated to a linear scan. The four number-less builders now derive one: **Metrologia → the volume** (`Metrologia 55 1A 06007` → `"55"`), **SI Brochure → `edition`** for the brochure and **`variant`** for the derived products (`"9e"`, `"Appendix 3"`, `"Concise"`, `"FAQ"`), **MEP → `mep_code || report_code`** (`"S1"`, `"KUPRTM"`, `"BIPM-2019/05"`). The Metrologia key is deliberately the **coarse, clustering** one (all articles of a volume share a bucket — 61 buckets, median 81), matching the IETF draft-slug and IANA registry-slug convention; **per-article distinctness comes from the MR string, not from `number`**. Two groups stay `number`-less **on purpose** (7 rows of 7,922, so 99.91% coverage): the ordinal-less committee declarations (`CGPM DECL (1889)`, upstream `1889-00.yaml`) and the journal-level `Metrologia` record — filling them would move `urn:bipm:cgpm:decl::1889`'s documented **empty number segment**; both are pinned by `spec/pubid/bipm/root_number_spec.rb` so the gap stays visible. **`number` is not stored twice where it would merely duplicate another key.** A Metrologia article's `volume` is a **derived reader** (`def volume; number&.to_i; end` on the `MetrologiaArticle` leaf), not an attribute — the IANA `registry` / IETF `series` pattern. That one case is essentially the whole duplication: 6,204 of the 6,206 published rows carrying a derived `number` are articles, so the change shrinks the serialized ids by **9.6%** and was verified to reproduce the published Integer `volume` for all 6,205 article rows. It is safe as a plain method only because `volume` is no longer a lutaml attribute **anywhere** in the hierarchy (a method shadowing a generated accessor corrupts attribute resolution). `:volume` stays listed in `NUMBER_SOURCE_ATTRIBUTES` — the base `#exclude` loop skips a non-attribute name, but `exclude(:volume)` must still clear the key it derives from. **`edition`/`variant` and `mep_code`/`report_code` DO stay**, and that is not an oversight: each pair shares one class, so the renderer needs to know *which* of the two a value is (`9e v3.01 (2019/2024, E)` vs `Concise`; `SI MEP S1` vs `Rapport BIPM-2019/05`). Deriving those would trade a duplicated key for a subtler discriminator rule across 5 corpus rows. The redundancy is **one-way, unlike the IEEE `CodeNumber` mixin** it superficially resembles: `Builder` is the **constructor of record**, and nothing rebuilds `number` afterwards — so `MetrologiaArticle.new(volume: 51, …)` has an empty key, and a legacy pre-`number` row deserializes with `number` nil (lutaml assigns attributes *after* `initialize`, so an `initialize` hook would not heal it either — and worse, `#exclude` rebuilds through `self.class.new`, so such a hook would silently re-fill a `number` the caller just excluded). What **is** handled is the exclusion direction: `NUMBER_SOURCE_ATTRIBUTES` (`volume edition variant mep_code report_code`) drives `#exclude` to clear `number` whenever the attribute it derives from is excluded — the "reset the WHOLE cluster" lesson recorded for CSA's year and IEEE's year/month/day. **Nothing about rendering changed**: no renderer or URN branch reads `number` for these families, verified by a corpus diff — `to_s` and `to_urn` are byte-identical before/after for all 7,920 parseable ids. **MR**: BIPM had **no** `mr_*` override at all and inherits none of the base hooks usefully — it keeps its publisher in the `PUBLISHER` constant (so `mr_publisher` was nil), its year in an `:integer` (not a `Components::Date`, so `mr_year` was nil), its edition in a `:string` (not a `Components::Edition`, so the base `mr_edition`'s `edition.number` **raised `NoMethodError`** on every SI Brochure) and its own `type_code` (not a `typed_stage`, so `mr_type` was nil). Result: 90 fixture ids collapsed onto **21** slugs, `""` for 41 of them. The base now overrides those four plus `mr_type`, and adds an `mr_slug(*parts)` helper; each **leaf** supplies `mr_type` + `mr_number_with_part`. `mr_slug` sanitizes **by charset** (`gsub(/[^a-z0-9]+/, "-")`), not by an enumerated escape list, so a field added later cannot leak an unsafe character — BIPM needs three 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 (hence `bipm.si-brochure.9e-v3-01.e`, not `…9e-v3.01.e`). Caveat pinned in the code: `-` is both the intra-segment join and the substitute, which is unambiguous only because no field feeding `mr_slug` admits a `-` today (`number`'s own internal `-` in `10-1` is safe because the `group` before it cannot contain one). The **group is load-bearing in the number segment** for CommitteeDocument/Meeting/Guide (`CCTF REC 2` vs `CCEM REC 2`; the 17th CGPM vs the 17th CIPM meeting; `CCL-GD-MeP-1` vs `CCEM-GD-RSI-1` — the guide sequence restarts per committee, so both carry number `"1"`). Verified over the corpus: **7,920 distinct slugs for 7,920 ids, zero collisions, zero non-filename-safe slugs.** Three **deliberate collapses**, pinned by `spec/pubid/bipm/mr_string_spec.rb`: `form` (short vs long committee spelling) and the MEP/Guide `appendix`/`annex`/`part` full-content tail are omitted, because MR is a canonical *document* slug and the URN already collapses them; `language` **is** kept, because the E and F records are distinct files upstream. **Watch out**: the long French spelling is *not* merely another rendering — `Builder#build_committee`/`build_meeting` record it as `language: "F"`, so `Résolution 1 de la CGPM (1927)` names the **French record** and correctly differs from the language-neutral `CGPM RES 1 (1927)`; only a same-language pair collapses. **Note on the determinism landmine**: BIPM declares `attribute :number, :string` on the **shared** `Pubid::Bipm::Identifier` (the IHO/JIS/GOST pattern), not on the leaves as IEEE/IETF/IANA/CIE do — it predates that lesson and is unchanged here, so `spec/pubid/bipm/root_number_spec.rb` carries the structural tripwire (the base *and* all six leaves must resolve `number` to `Lutaml::Model::Type::String`) and **is only meaningful under the full `bundle exec rake`**. **relaton note**: `relaton-data-bipm` must regenerate `index-v2.yaml` to gain the key (and to drop the now-unstored `volume`; `Relaton::Bipm::Bibliography#id_hash` reads `pubid.volume`, which the derived reader keeps working unchanged). A pre-`number` row degrades **silently, not loudly** — lutaml ignores unknown keys and `Relaton::Index::FileIO#id_supported?` skips its round-trip check for concrete subclasses (every BIPM id is a leaf) — so no `require_number!`-style raise is added (rendering does not depend on `number`, and `CGPM DECL` is legitimately number-less). `Relaton::Bipm::Bibliography#get_bipm` also still calls the **block** form `index.search { |r| … }`, which passes `id = nil` and skips `candidates_by_number` entirely, so nothing narrows until it adopts the id form.
+
+- **BIPM loose consumer forms (retiring `Relaton::Bipm::Id`)**: `Relaton::Bipm::Bibliography` could not use pubid as its **query** parser — it kept a bespoke regex grammar (`Relaton::Bipm::Id`) because `Pubid::Bipm.parse` rejected the spellings real references use. The grammar now accepts them, so relaton can match pubid-to-pubid like every other flavor. **All of these are NORMALIZING parses — the identifier renders back in BIPM's canonical spelling, never the input** — which is the whole point (a loose query must produce an identifier equal to the index row's), and which is exactly why they must **never** go into the byte-exact `spec/fixtures/bipm/identifiers/pass/` (the `CIPM/2005-06(REV)` precedent); their expectations live in `spec/pubid/bipm/loose_consumer_forms_spec.rb`. Six constructs: **(1) Meeting word order** — `meeting_en` gained a `<group> Meeting <n>` branch and `meeting_fr` gained a plain-`e` ordinal branch (`CIPM 111e Réunion (2022)`) and a `<group> Réunion <n>` branch, all normalizing to `CCTF 14th Meeting (1999)` / `CIPM 111<sup>e</sup> réunion (2022)`. **(2) `committee_group_fr`** — a French type name in the English (group-leading) word order (`CIPM Décision 101-1 (2012)` → `Décision 101-1 du CIPM (2012)`). Its slot in `group_leading` is **after `committee_long_en`**, which is load-bearing: `Action` and `Statement` are in *both* `TYPE_NAME_EN` and `TYPE_NAME_FR`, so the English rule must claim them first or `CIPM Action 5 (2010)` would flip to French. Like the existing French rules it sets `language: "F"` — information the user typed, which a consumer can always widen away but could never recover. **(3) `GROUP_ALIASES`** (`CCDS`→`CCTF`) and **(4) `LANGUAGE_ALIASES`** (`EN`→`E`, `FR`→`F`, longest-first in the `lang` rule so `EN` is never read as a bare `E`): both are resolved in the **builder**, so an alias never reaches an attribute and the index stores only the current name and the one-letter code. `PARSEABLE_GROUPS` (= `GROUPS + GROUP_ALIASES.keys`) is what the `group` rule alternates over; `GROUPS` itself is unchanged, so nothing else sees the alias. **(5) `si_brochure_section`** — the bare `SI Brochure` and `SI Brochure Part 1`. Neither names an edition, so **both are partial references with a nil `number`** that wildcard every edition (the date-less `CCTF REC 2` reading). `Part N` points at a section *inside* the brochure — there is no `si-brochure-part-1.yaml` upstream and relaton's `Id` deletes `:part` before comparing — 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. **A Parslet fact worth recording, because it contradicts what several comments in this repo imply**: Parslet threads `consume_all` down through an alternation, so an alternative matching only a **prefix** counts as a failure and the next one is tried — verified by reordering. `si_brochure_section` therefore cannot truncate `SI Brochure Concise` whatever its slot, and `committee_bare` could not shadow a typed form even if it came first. Alternation order decides **only** between two alternatives that both consume the *whole* input — which is exactly the `committee_long_en`-before-`committee_group_fr` case above, and the only ordering here that is genuinely load-bearing (verified: flipping it renders `CIPM Action 5 (2010)` as the French `Action 5 du CIPM (2010)`, a different record). The `BIPM ` prefix was also made **optional on the main `si_brochure` rule** (it already was on the variant rule): `si-brochure.yaml` stores its docnumber *without* it, and `Relaton::Bipm::Bibliography.search` strips a leading `BIPM ` before pubid ever sees the string — so `SI Brochure 9e v3.01 (2019/2024, E)` used to be a hard parse failure. **(6) `TYPE_WORD_ALIASES`** — a **data-corruption fix**: `Declaration`/`Déclaration` were in the `type_name_en`/`type_name_fr` alternations but **not** in `TYPE_WORD_TO_CODE` (which is built from `TYPE_NAME_EN`/`TYPE_NAME_FR`, where DECL's name is `Statement` in both languages), so `CGPM Declaration 1 (1971)` parsed with `type_code` **nil** and rendered as the corrupt `"CGPM  1 (1971)"` (double space), `Déclaration 1 du CGPM (1971)` as `" 1 de la CGPM (1971)"`. Both now map to DECL and render `Statement`. **The matching contract relaton needs** (pinned by the spec against real `index-v2` rows): committee-document and meeting rows are stored **language- and form-neutral** — verified, all 1348 + 367 — so the BIPM stem is **`pubid.exclude(:language, :form)`**, and every loose form reduces under it to the identifier rebuilt from its row. The SI Brochure is the exception: a nil-`edition` query must match *any* `SiBrochure` row, which is what `Id#id_hash`'s `{group: "SI", type: "Brochure"}` collapse already meant. **Also fixed here**: `UrnParser#build_metrologia`/`#build_si_brochure` never set the derived `number`, so a URN round-trip silently emptied the relaton index key (the shared `"flavor URN round-trip"` example only compares `to_urn`, so it was invisible) — now set from the same source the builder uses, guarded by a `presence` helper because an unfilled URN segment is `""`, not nil. **Verified**: all 7,922 published `relaton-data-bipm` rows re-parse from their own `to_s` with an identical hash, class and MR slug (0 mismatches, 0 MR collisions), and all 90 pass fixtures stay byte-exact. **Deliberately NOT changed:** `CCTF Recommendation 2009-02` still reads as the literal number `2009-02` while the index keys that document under `2` — genuinely ambiguous, since `NNNN-NN` is a real BIPM number form (`CIPM 2005-06`), so the consumer keeps a fallback. **Known pre-existing gap, deliberately untouched:** the SI Brochure URN carries only language/edition/version/years, so `Concise`, `FAQ` and `Appendix 3` — three distinct documents — already share `urn:bipm:si-brochure::::`, and the new bare/section forms join that bucket (defensibly, being partial references rather than distinct documents). Fixing it needs a URN-shape decision plus a matching `UrnParser` branch. `Pubid.parse` auto-routing does not resolve **any** BIPM form today (also pre-existing), so `PREFIXES` was left alone — adding `CCDS` there would change nothing observable. (hand-off: bipm-loose-consumer-forms; consumer follow-up: relaton__relaton__bipm-drop-id-parser-for-pubid.)

data/lib/pubid/bipm/builder.rb

@@ -161,3 +161,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Bipm::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/bsi/CLAUDE.md

@@ -0,0 +1,93 @@
+# BSI flavor notes
+
+BSI wrappers, adopted norms and cross-flavor sets.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/bsi/` or `spec/pubid/bsi/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **One EC representation**: BSI's Expert-commentary suffix is modelled *only* as an outer `Identifiers::ExpertCommentary` wrapper (never a boolean on the inner adopted norm), so `#base_document`/`#base` peel cleanly. The builder's adopted path (`build_adopted_identifier`) is the single place that wraps supplements + EC; `Builder#build` must **not** re-wrap the adopted branch (that caused a double-`ExpertCommentary` that broke `base`).
+
+## From the root note "`number`/`part`/`subpart` retyped to `:string` — tranche 1 of 3 (ansi, api, bsi, cen_cenelec, idf, jcgm)"
+
+**Hand-off `bsi-set-cross-flavor-type` is closed as a side effect, and a pin on `main` is what proved it.** A `BS ISO 20400 + …` set holds *ISO* identifiers, and BSI declared `number`/`part`/`subpart` as its **own** `Bsi::Components::Code`, so `to_hash` raised `IncorrectModelError` — the cross-flavor attribute-type bug already fixed once on `Ieee::Identifiers::AdoptedStandard`. Retyping the three attributes to `:string` **removes the offending type outright**: there is no longer a BSI-specific component for a foreign identifier to mismatch, so no widening was needed. **74 BSI ids that previously raised on `to_hash` now serialize**, and the set round-trips through `from_hash` to the same class, hash and `to_s`. Merging `main` turned its `expect { id.to_hash }.to raise_error` pin red, which is how this surfaced; it now asserts the repair. Note the set's `#root` still reaches an `Iso::Components::Code` until tranche 3 — `root.number.to_s` is what relaton keys on, so the index contract holds either way.
+
+## From the root note "Wrapper index keys (`root.number`) — the number was already there, one level down"
+
+**The second half of the `number` landmine is a plain method shadowing a real attribute reader**, and `Bsi::Identifiers::AdoptedEuropeanNorm` still has it (`#number`, `#date`, `#part`, `#subpart` all delegate to `adopted`, the attribute named `adopted_identifier` before the rename recorded in `lib/pubid/cen_cenelec/CLAUDE.md`) — pre-existing, deliberately not removed here because `bsi/urn_generator.rb` reads `identifier.number` generically and had no other source. It now has one: that generator falls back to `identifier.root.number`, which recurses where the one-level delegation did not. That alone repaired **80 identity-free BSI URNs** — every `AddendumDocument`, `SupplementDocument`, `BundledIdentifier`, `Set`, `CommitteeDocument`, `StandaloneAmendment` and `AdoptedEuropeanNorm` in the corpus emitted the bare `urn:bsi:bs` or `urn:bsi:dd`, i.e. one URN per publisher for hundreds of documents. **0 URNs got shorter**; a non-wrapper's `root` is `self`, so ordinary identifiers are untouched. Removing the shadowing delegations themselves is now unblocked but is left to a follow-up (hand-off `bsi-set-cross-flavor-type`), which also records that `AdoptedEuropeanNorm` fails the round-trip on *values* rather than keys.
+
+## From the root note "Parse-failure error contract — uniform across every flavor"
+
+**The unanchored/anchored mismatch that silently returned nil for 49 identifiers.** `Builder#build_adopted_identifier` (`lib/pubid/bsi/builder.rb`) chooses among adoption shapes. Its first branch tested
+
+```ruby
+if adopted_str_clean.match?(/EN\s+(ISO\/IEC|IEC|ISO)/)   # UNANCHORED
+  iso_iec_str = adopted_str_clean.sub(/^EN\s+/, "")      # ANCHORED
+```
+
+`"CEN ISO/TS 12180-1:2007"` **matches** the test — the substring `"EN ISO"` sits inside `"CEN ISO"` — but the anchored `sub` finds no `^EN ` and changes nothing. The branch then asks whether the (unchanged) string starts with `ISO`/`IEC`, which `"CEN …"` does not, so `adopted_id` stayed `nil` and `build` returned `nil` for the whole identifier. Anchoring the test to `/\AEN\s+(ISO\/IEC|IEC|ISO)/` lets a `"CEN …"` string fall through to the `start_with?("EN", "CEN", "CLC", …)` branch, which hands it to `Pubid::CenCenelec.parse` — where it belongs, and which parses it correctly.
+
+**Measured**: 49 `DD CEN ISO/…` / `PD CEN ISO/…` identifiers in BSI's own `pass/` fixtures returned `nil` on `main`. **48 now build**, with `to_s` byte-exact against the input, real URNs (`urn:bsi:dd:12180:-1:2007`), MR slugs and a non-empty `root.number` — so they now key correctly in relaton-index instead of keying `""`. The 49th, `PD CEN ISO/TS 19166:2025 - TC`, now **raises** `Parslet::ParseFailed`; that is the honest outcome, since it never parsed, and reclassification moved it from `pass/` to `fail/`.
+
+**Two lessons worth more than the fix.** (1) An **unanchored test paired with an anchored repair** is a silent-nil generator: the test admits inputs the repair cannot handle, and every branch below then misses. Check that a guard and its remedy use the same anchoring. (2) The classifier had bucketed all 49 into **`spec/fixtures/bsi/identifiers/pass/nil_class.txt`** — a `pass/` file named after the *failure mode*, holding `!input!` lines with an empty rendered half. A fixture bucket named for a failure is a defect report that has been filed and ignored; the file no longer exists after reclassification.
+
+Note the 48 recovered ids raise `IncorrectModelError` on `to_hash` — pre-existing and unrelated: **565 of BSI's 1497 ids already did on `main`**. They join that group rather than forming a new one.
+
+## The wrapper-slot survey: which wrappers do not name their parent `base`
+
+Moved here from the root CLAUDE.md's parent-accessor bullet, which keeps a one-line pointer (the root file is size-bounded by `spec/pubid/flavor_notes_spec.rb`). It is recorded under BSI because BSI is the flavor the survey led to converting; the CEN, IEEE and IEC halves are in their own notes.
+
+**The root CLAUDE.md's uniform-`base` rule overstated its coverage, and the survey that measured the gap is worth keeping.** The `base_identifier` → `base` sweep did not reach the **adoption** wrappers: a later branch renamed `adopted_identifier` → **`adopted`** in CEN/CENELEC and BSI, a *second* name rather than the uniform one. `base_identifier` is genuinely gone (0 occurrences in `lib/`), but three camps remain, and telling them apart is the useful part. **Camp A — `adopted*` IS the parent slot**: `CenCenelec::Identifiers::{AdoptedEuropeanNorm,EuropeanPrestandard}` and the legacy second root `CenCenelec::Identifiers::Base` (whose `adopted` is typed narrowly to CEN's own `Base`, not `::Pubid::Identifier`); `Evs::Identifier#adopted_identifier`; and `Ieee::Identifiers::AdoptedStandard`, where `ieee_identifier` is the parent and `adopted_identifiers` the collection. **Camp B — `adopted*` is a sibling cross-reference and `base` is present, so it is NOT a divergence**: `Gost::Identifiers::IdenticalAdoption` (`base` = the GOST document, `adopted` = the foreign one) and `Gost::Identifiers::Harmonized` (`adopted_identifiers`); both define `def number; base&.number; end`, reading `base`. **Camp C — a parent slot under some third name**: `Pubid::BundledIdentifier#base_document` and `Iso::BundledIdentifier#base_document` (the **attribute shadows the `#base_document` method** of the matching primitives, and neither defines `#root`), `Ieee::Identifiers::{DualIdentifier,IecIeeeCopublished}`, `Iec::Identifiers::TestReportForm#cispr_identifier` — none of those four has `#root` — plus `Csa::Identifiers::Bundled#bundled_with`, `Cie::Identifiers::Bundle#ids` and the `identifiers` collections, which do. `Itu::Identifier#common_text_twin` is a co-published twin, not a parent.
+
+**What the divergence costs, measured rather than assumed.** `BS ISO 8601:2019` and `NA to BS EN 1991-1-1:2002` kept a correct index key while `root` returned the *wrapper*, because a hand-written `#number` delegation repaired the one symptom the index looks at; `EVS-EN 18216:2026` keyed the **empty string** (fixed separately by renaming EVS's slot to `base`). So a `#number` delegation on a wrapper is not a fix — it hides the missing `#root` from the only test anybody runs. **BSI is now converted** — see the sections below, including why the delegations were removed even after pubid#379 had fixed the `to_hash` raise they caused, and the `Identifiers::RootIdentity` mixin that replaced them. **`Components::Adoption` (`lib/pubid/components/adoption.rb`) already models an adoption with a `base` slot** and documents itself as the union of the BSI/CEN/CSA/IEEE shapes — it is autoloaded and used **nowhere**, so the unification was designed and never wired up. Finally, `Iec::Identifiers::ConsolidatedIdentifier#base_document` returns `identifiers&.first` with no recursive `&.base_document`, unlike its BSI, CSA and CEN counterparts — a one-level peel where the others peel fully.
+
+## Cross-flavor adoption `to_hash` (pubid#379)
+
+**Cross-flavor adoption `from_hash` (pubid#379) — the empty-subclass disease, third occurrence.** `Pubid.from_hash(parse("BS EN 10077-1:2006").to_hash)` raised `IncorrectModelError: attribute 'date' value is a 'Pubid::Components::Date' but should be a 'Pubid::Bsi::Components::Date'` — on **to_hash**, before rehydration even began. The adoption wrappers (`AdoptedEuropeanNorm`, `AdoptedInternationalStandard`) delegate their `date` reader to the foreign identifier they wrap, whose date is the shared component; the outer attribute table demanded `Bsi::Components::Date`, an **empty subclass that adds nothing** (`class Date < Pubid::Components::Date; end`). The fix is the `bsi-set-cross-flavor-type` medicine verbatim — retype `date` on `Pubid::Bsi::Identifier` to `::Pubid::Components::Date` — which repaired every `BS EN …`/`BS ISO …`/`BS IEC …`/`BS EN ISO …` adoption AND the EVS national adoptions of the same family (the nested CEN dispatch itself was already correct: `apply_mappings` → `concrete_class_for` → `TypeResolver` routes the inner `_type` to CEN's class). The same mismatch on `type` broke the **BIP/PP/HB leaves** ("BIP 2225:2022" failed to_hash pre-existing on main) — their builders materialize a shared `Components::Type` — so `type` took the same retype, and the three now-redundant `attribute :date, Bsi::Components::Date` redeclarations on `BritishIndustrialPractice`/`PracticeGuide`/`Handbook` were deleted (the base now carries the declaration). `publisher`/`common_year` keep the BSI subclasses: nothing foreign ever flows into them, and the builder constructs the BSI types. **The pattern to remember for this flavor**: an empty `Bsi::Components::*` subclass on an attribute is a REJECTION RULE for foreign values, not a behavior — any attribute a wrapper delegates to a nested cross-flavor identifier must be typed with the shared component.
+
+## The adoption wrappers hold the adopted document in `base`
+
+This closes part 2 of hand-off `bsi-set-cross-flavor-type` — the shadowing delegations that branch deliberately left in place.
+
+**Three names became one.** `AdoptedEuropeanNorm#adopted`, `AdoptedInternationalStandard#adopted` and `NationalAnnex#base_doc` are now all **`base`**, the uniform parent accessor. Nothing inherits from those three classes, so the redeclaration is not the determinism landmine; `base` was free on all of them, and `Identifiers::Amendment` had already declared `attribute :base` over the nil-returning method on `::Pubid::Identifier`. The wire key follows the attribute name (BSI declares no `key_value` block), so a stored row's `adopted:` / `base_doc:` becomes `base:` — there is no `relaton-data-bsi`, and no relaton gem reads `.adopted`, so nothing published needs regenerating.
+
+**Everything else spelled `adopted_*` in `parser.rb` and `builder.rb` is a parse-tree key** (`adopted_string`, `adopted_org`), a different namespace, and stays. Two reads also stay because they touch **CEN's** attribute, not BSI's: `builder.rb` constructing a `CenCenelec::Identifiers::AdoptedEuropeanNorm`, and the old `delegate_target` that unwrapped one CEN layer.
+
+**The delegations were the actual defect, not the name — but not the `to_hash` raise.** All three classes defined `#number`, `#date`, `#part` and `#subpart` as plain methods reading one level down, each shadowing a real lutaml accessor. `#date` returned the *adopted flavor's* `Pubid::Components::Date`, and that is what made `to_hash` raise — but **pubid#379 (above) had already fixed the raise by widening the attribute type**, and kept the delegations. This branch removes the delegations for the reasons that remained after #379: they made `id.base` nil and `#root` need overrides, they answered with a value for a plain member and nil for a wrapped one, and they re-emitted the nested document's `number`, `part` and `year` at the top level of every wrapper row. The #379 type widening stays necessary regardless — the BIP/PP/HB leaves still materialize a shared `Components::Type`.
+
+**Deleting them moved identity onto `#root`, and that had to be done at every surface.** `to_s` was safe from the start — `render_adopted_european_norm` and `render_adopted_international_standard` read only `base`, `edition`, `reaffirmation_year` and the translation flags, never `number` or `date`. Two other surfaces did read them:
+
+- **`urn_generator.rb`** already had `identifier.number || identifier.root.number`. A private `identity(attr)` now applies the same fallback to `part`, `subpart`, `date` and `year`. `#root` is `self` for a non-wrapper, so an ordinary identifier reads its own value and nothing moves.
+- **the MR slug**: the base `mr_number_with_part` and `mr_year` read the receiver's own attributes, which a wrapper leaves nil. `Identifiers::RootIdentity` (`lib/pubid/bsi/identifiers/root_identity.rb`) is a two-method mixin — `root.equal?(self) ? super : root.mr_number_with_part` — included by the nine wrapper classes. It is a **mixin in nine named classes, not a prepend into every chain**: CLAUDE.md's annotated-rendering bullet records that inserting a module into every identifier's ancestors caused order-dependent nondeterminism, and this does not touch an unrelated chain.
+
+**The four classes that needed it beyond the three renamed ones were found by measuring, not by reading.** Deleting the delegations first made `ConsolidatedIdentifier` (75 ids) and `ExpertCommentary` (17) slug the bare `bs`, because their own one-level `#number` delegations had been landing on the adoption's delegation. The mixin restored **the MR slug** for them exactly — and only that; `#number` and `#date` themselves are dealt with below. That in turn exposed a **pre-existing** collapse of the same shape — `AddendumDocument` (22), `BundledIdentifier` (27), `SupplementDocument` (18) and `Set` (1) already slugged the bare `bs` on `main`, i.e. **68 documents sharing one output FILENAME**; the mixin repairs those too.
+
+**A one-level delegation is worse than none, so `ConsolidatedIdentifier` and `ExpertCommentary` lost theirs as well.** Their `#number` / `#part` / `#parts` / `#date` / `#year` read `identifiers.first` / `base` — one level. So the *same accessor* answered with the member's value when that member was a plain standard and with nil when it was itself an adoption. A code review caught that the mixin left this half untouched. Re-delegating through `#root` was rejected: for `date` it hands lutaml a foreign `Pubid::Components::Date` and reinstates the very raise this branch removes, and for `number` it puts back the duplicate top-level key. So the rule is now uniform and stated: **a BSI wrapper owns no identity; `#root` carries it, for every layer.** Measured consequence on the wire: 33 consolidated and commentary rows lose a top-level `number` and 25 lose a `part` — **every one a duplicate of a value still present in the nested member**, and `root.number` is unchanged for all 1501 ids, so no identity and no index key is lost. `spec/pubid/bsi/adoption_base_spec.rb` locks the rule over all nine wrapper classes: none may own an identity accessor, and each must resolve a non-empty `root.number`.
+
+**One `collection: true` defect fell out, and it is the documented one.** `NationalAnnex#na_supplements` was `collection: true` with no default: the builder always passes an array, so a **parsed** NA held `[]`, while the serialized hash omits an empty collection, so a **deserialized** one held `nil` — and the two were not `==`. That is the 3GPP `parts` lesson in CLAUDE.md verbatim, with the same one-line remedy (`initialize_empty: true`) and the same blast radius: `#matches?` is `exclude(*ignore) == other.exclude(*ignore)`, so every index lookup of a supplement-less NA returned nothing, silently. `from_hash(to_hash) == id` rose by a further 10 ids.
+
+**Verified by replaying a baseline captured from `main` after pubid#379, over all 1501 pass-fixture ids.** `to_s`, the identifier class and `root.number` are **byte-identical for every one**. URNs: 56 changed, **0 shorter**, distinct 1458 → 1463. MR slugs: 116 changed, **0 shorter**, distinct 1342 → **1402**, and the bare-`bs` bucket is empty. `urn:bsi:dd:11079` — the identity-free URN every `DD` adoption shared — is now `urn:bsi:dd:11079:1999`. `to_hash` raises stay at 0 (#379's work) and `from_hash(to_hash).to_hash == to_hash` stays at 1499; `from_hash(to_hash) == id` goes **1451 → 1461**, the ten `NationalAnnex` ids the `na_supplements` fix repaired. **The wire shape changes for 491 rows, all in six wrapper classes**: `adopted` (543) and `base_doc` (18) become exactly 561 `base`; `amendment_number`/`amendment_year` become `number`/`year`; and the wrappers' duplicated top-level `number`/`part`/`year` go. **No information is lost, and that was checked rather than inferred from the key tallies** (which net the removals against the renames): rebuilding every identifier from its new hash reproduces `to_urn` and `root.number` for all 1501 and `to_s` for 1500 — the one miss, `BS 2000-0:Addendum 1:1983`, rebuilds as `Addendum No.` on `main` too (an empty `addendum_type` that `to_hash` drops and `from_hash` restores as its default).
+
+**One MR gap stays, pinned rather than fixed.** `mr_edition` (`lib/pubid/identifier.rb`) reads `edition.number`, but BSI declares `edition` as a plain `:string`, so `to_mr_string` raises `NoMethodError` for the **40** pass-fixture ids that carry an edition (`BS HD IEC 60364-8-81 ED1`). Unchanged by this branch, and the same crash CLAUDE.md records for BIPM, ASTM and IEEE. `spec/pubid/bsi/adoption_base_spec.rb` asserts the raise, so a fix turns it red.
+
+**`KNOWN_ROUND_TRIP_FAILURES["bsi"]` does not move: it stays at 2**, where pubid#379 left it, in `spec/pubid/number_string_retype_spec.rb`. Earlier in this branch, measured against the pre-#379 `main`, it read 597 → 191; the merge replaced both numbers, and the exact-count convention of that file is what made the drift visible instead of silent.
+
+## The attached amendment keys its ordinal as `number` and its year as `year`
+
+`Identifiers::Amendment` held `amendment_number` / `amendment_year` while the `number` it inherits from `SingleIdentifier` stayed nil — the same private-name shape that `StandaloneAmendment` and `CommitteeDocument` were already converted out of. An amendment row now reads `number:` / `year:` like every other BSI row. `to_s`, `to_urn` and `root.number` are byte-identical for all 1501 pass fixtures.
+
+**This does not make the ordinal a document number**, which was the objection to the change and is worth recording because it is nearly true. `number` holds `"1"` (or `"11"`, or `"AA"`), and the amended standard is reached through `base`, which `#root` walks — so `root.number` is `4592`, not `1`. The failure mode being avoided is real and this branch measured it elsewhere: `BS EN IEC 61535/AMD1/FRAG1` slugged `bs.1` on `main`, an ordinal read where a document number belongs. The guard is that **8 of the 114 attached Amendment objects in the corpus have a nil `base`** — the supplements of a national annex, built with `base: nil` — so for those, and only those, `root` is the amendment itself. They are never a top-level parse result (an attached amendment is always nested), so no index row is keyed from one; if that ever changes, those 8 are where to look.
+
+**The year was originally moved into a declared `year` attribute, NOT the inherited `date` — since reverted, see "The `exclude` recursion boundary" below.** Both spellings produce the `year:` key — a `Bsi::Components::Date` flattens to `year` under the canonical scalar rule — but `#exclude` recurses into nested identifiers, so with the year in `date`, `exclude(:date)` on the consolidated identifier dropped the amendment's year too: `BS 7273-4:2015+A1:2021` excluded to `BS 7273-4+A1` instead of `BS 7273-4+A1:2021`. An amendment's year belongs to the supplement, not to the standard, and `spec/pubid/bsi/parse_gaps_spec.rb` had pinned exactly that. A declared `year` (the shape ashrae, bipm, gost, ieee, jis, nist and ogc use for their own edition year — unrelated to this fix, and unaffected by it) only ever solved half the problem: it protected against a bare `exclude(:date)`, not `exclude(:year)`, since the flat-scalar rule skips the `date` → `year` rename precisely when `year` is a real attribute. The general fix protects the *inherited* `date` directly, so `Amendment`/`Corrigendum` no longer need a bespoke `year` attribute at all.
+
+**`supplement_number` / `supplement_year` were then deleted.** Once both supplement classes declared `number` and `year` under those names, the two methods were one-line aliases in every implementation — BSI and CEN alike. `supplement_type` stays: nothing else names the class, and relaton detects a supplement with `respond_to?(:supplement_type)`. This **is** a consumer break: relaton's BSI matching (`lib/relaton/bsi/bibliography.rb`) and CEN hit key (`lib/relaton/cen/hit_collection.rb`) called both aliases, so they must read `number` / `year` — hand-off `relaton__relaton__pubid-supplement-number-year`. **`Corrigendum` took the same conversion**, so `number` / `year` is now uniform across both supplement classes. It has **0 objects in the BSI pass-fixture corpus**, so the corpus replay proves nothing about it — the four forms that parse (`+C1:2016`, the year-less `+C1`, a corrigendum and an amendment together, and the `NA+C1:…` form) are exercised directly in `spec/pubid/bsi/adoption_base_spec.rb` instead, each asserting `to_s`, the URN and `from_hash(to_hash) == id`. One belief corrected while writing them: the unnumbered `+C:2016` form that CEN spells `AC` does **not** parse in BSI, so a nil ordinal is not a case to design for here; a nil `year` is.
+
+**The year is a `:string`, and that settled a cross-flavor disagreement rather than only a cosmetic one.** The old `amendment_year` was an `:integer`, so an amendment row read `year: 2012` where a standard row reads `year: '2006'` — the same key name, two types, inside one consolidated identifier. Worse, relaton compares a supplement's year across flavors, and CEN's was the String `"2005"` while BSI's was the Integer `2012`. The base `#year` reader is `date&.year&.to_s`, and 6 of the 9 flavors with a real `year` attribute declare `:string`, so String is the contract. `Corrigendum` took the same `:string` `year`, so both supplement classes now agree with each other and with CEN. **This still holds after the `year` attribute was reverted to the inherited `date`**: the reader `date&.year&.to_s` still returns a String, so `amendment.year`/`corrigendum.year` and the `to_hash` `"year"` key are unchanged.
+
+## The `exclude` recursion boundary: `supplement_date_attributes`
+
+`Pubid::Identifier#exclude` recurses into every nested identifier (`base`, `identifiers`, …) at unlimited depth, which is right for a wrapper (its own date is nil; the real date lives on the document it wraps) and wrong for a supplement, which owns its own date. The `year`-not-`date` attribute described above was a partial dodge of this — it protected against a bare `exclude(:date)` but not `exclude(:year)`, because the top-level nil-ing loop matches by attribute *name*.
+
+The general fix (`metanorma__pubid__exclude-recursion-depth` hand-off) promotes CEN/CENELEC's pre-existing `#exclude` override — which ran `super` then "put back" the supplement's own date unless `:supplement_year` was explicitly passed — into `::Pubid::Identifier` itself, as a class hook: `self.supplement_date_attributes` (default `[]`, meaning "protect nothing, recurse exactly as before"). `Amendment`/`Corrigendum` now declare `supplement_date_attributes => %i[date]` and use the **inherited** `date` component — no bespoke `year` attribute needed, and no per-flavor `#exclude` override either. `CenCenelec::Identifier#exclude` was deleted for the same reason: the base class now does what it did.
+
+Verified: `spec/pubid/supplement_date_attributes_spec.rb` exercises the mechanism directly; `spec/pubid/bsi/parse_gaps_spec.rb`, `match_primitives_spec.rb` and `adoption_base_spec.rb`, and `spec/pubid/cen_cenelec/relaton_blockers_spec.rb`'s 10 pinned `:supplement_year` cases, all pass unchanged. Because the new logic only fires when `supplement_date_attributes` is non-empty, every other flavor (including ISO/IEC, which deliberately keep a supplement's year in `date` with no protection — see `lib/pubid/cen_cenelec/CLAUDE.md`) is untouched.
+
+**Open question, not resolved here: `#dated_version_of?`/`#draft_of?` on a bare BSI supplement.** Both build on `matches?(other, ignore: [:date, :year, …])`, which — like every other bare `:date`/`:year` exclusion — now protects a supplement's own date unless `:supplement_year` is also passed. Two standalone `BS 7273-4:2015+A1:2021`/`...+A1:2022` objects were `dated_version_of?` each other before this branch (BSI's old `year`-attribute dodge never protected against `exclude(:year)`) and are not after. **Whether that's the right answer is genuinely unclear and deliberately left open pending feedback** — one reading is that this just makes BSI consistent with CEN/CENELEC, which already behaved this way before this branch (its pre-existing per-flavor `#exclude` override had the same protection); the other is that these two generic relational predicates should be widened to accept a `:supplement_year`-aware `ignore` set so they can still recognize two differently-dated editions of the *same supplement* as related. Neither predicate was touched in this branch — this is recorded, not decided. Locked (as current behavior, not as a verdict) by `spec/pubid/supplement_date_attributes_spec.rb`.

data/lib/pubid/bsi/builder.rb

@@ -887,15 +887,15 @@ module Pubid
           if supp[:type] == :amendment
             Identifiers::Amendment.new(
               base: nil, # NA supplements don't wrap base
-              amendment_number: supp[:number],
-              amendment_year: year_val&.to_i,
+              number: supp[:number]&.to_s,
+              year: year_val&.to_s,
               separator: supp[:separator] || "+",
             )
           else
             Identifiers::Corrigendum.new(
               base: nil,
-              corrigendum_number: supp[:number],
-              corrigendum_year: year_val&.to_i,
+              number: supp[:number]&.to_s,
+              year: year_val&.to_s,
               separator: supp[:separator] || "+",
             )
           end
@@ -903,7 +903,7 @@ module Pubid
 
         Identifiers::NationalAnnex.new(
           na_supplements: na_supps,
-          base_doc: base_id,
+          base: base_id,
         )
       end
 
@@ -1383,7 +1383,7 @@ module Pubid
           identifier = if adopted_id.class.name.start_with?("Pubid::CenCenelec::")
                          Identifiers::AdoptedEuropeanNorm.new(
                            publisher: Components::Publisher.new(body: bsi_prefix),
-                           adopted: adopted_id,
+                           base: adopted_id,
                            edition: final_edition&.to_s,
                            translation_lang: data[:translation_lang]&.to_s,
                            translation_upper: data[:translation_upper]&.to_s,
@@ -1396,7 +1396,7 @@ module Pubid
                          # Otherwise it's ISO/IEC, use AdoptedInternationalStandard
                          Identifiers::AdoptedInternationalStandard.new(
                            publisher: Components::Publisher.new(body: bsi_prefix),
-                           adopted: adopted_id,
+                           base: adopted_id,
                            edition: final_edition&.to_s,
                            translation_lang: data[:translation_lang]&.to_s,
                            translation_upper: data[:translation_upper]&.to_s,
@@ -1447,16 +1447,16 @@ expert_commentary: nil, expert_commentary_topic: nil)
           if supp[:type] == :amendment
             Identifiers::Amendment.new(
               base: base,
-              amendment_number: supp[:number],
-              amendment_year: year_val&.to_i,
+              number: supp[:number]&.to_s,
+              year: year_val&.to_s,
               separator: supp[:separator] || "+",
               amd_suffix_form: supp[:amd_suffix_form] ? true : false,
             )
           else
             Identifiers::Corrigendum.new(
               base: base,
-              corrigendum_number: supp[:number],
-              corrigendum_year: year_val&.to_i,
+              number: supp[:number]&.to_s,
+              year: year_val&.to_s,
               separator: supp[:separator] || "+",
             )
           end
@@ -1493,3 +1493,5 @@ expert_commentary: nil, expert_commentary_topic: nil)
     end
   end
 end
+
+Pubid::Bsi::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/bsi/identifiers/addendum_document.rb

@@ -11,6 +11,8 @@ module Pubid
       # "BS 2000-0:Addendum 1:1983"
       # "BS 6034:1981:Addendum No. 1:1986"
       class AddendumDocument < SingleIdentifier
+        include RootIdentity
+
         attribute :base, ::Pubid::Identifier, polymorphic: true
         attribute :addendum_number, :string
         attribute :addendum_year, :integer

data/lib/pubid/bsi/identifiers/adopted_european_norm.rb

@@ -7,7 +7,12 @@ module Pubid
       # Example: "BS EN 10077-1:2006" where EN 10077-1:2006 is a CEN identifier object
       # Example: "BS EN ISO 8601:2019" where EN ISO 8601:2019 is a CEN AdoptedEuropeanNorm wrapping ISO
       class AdoptedEuropeanNorm < BritishStandard
-        attribute :adopted, ::Pubid::Identifier, polymorphic: true # CEN object
+        include RootIdentity
+
+        # The adopted CEN document, under the uniform parent accessor. `#root`
+        # and `#base_document` are inherited and walk it, so this class needs
+        # neither an override nor the delegating readers it used to carry.
+        attribute :base, ::Pubid::Identifier, polymorphic: true
         attribute :edition, :string
         attribute :translation_lang, :string
         attribute :translation_upper, :string
@@ -25,59 +30,6 @@ module Pubid
           nil
         end
 
-        # Walk to the adopted document for the relaton-index key.
-        #
-        # The `#number` delegation below is not enough on its own: a
-        # "DD ENV ISO 11079:1999" adopts a CenCenelec EuropeanPrestandard,
-        # which is ITSELF a wrapper around the ISO standard, so the delegation
-        # returned that wrapper's own (nil) number and the chain died one level
-        # short. `#root` recurses, so it reaches the ISO standard however many
-        # adoption layers sit in between.
-        def root
-          adopted ? adopted.root : self
-        end
-
-        # Delegate common methods to adopted identifier
-        def number
-          delegate_target&.number
-        end
-
-        def year
-          delegate_target&.year if delegate_target&.methods&.include?(:year)
-        end
-
-        def date
-          delegate_target&.date if delegate_target&.methods&.include?(:date)
-        end
-
-        def parts
-          delegate_target&.parts if delegate_target&.methods&.include?(:parts)
-        end
-
-        def part
-          delegate_target&.part if delegate_target&.methods&.include?(:part)
-        end
-
-        def subpart
-          adopted&.subpart if adopted&.methods&.include?(:subpart)
-        end
-
-        private
-
-        # The identifier that holds the number, part and date. For
-        # "BS EN ISO 8848:2021" the adopted document is a CEN adoption of an
-        # ISO standard, and the CEN adoption keeps no number of its own, so
-        # read through it to the ISO standard. The CEN class used to do this
-        # with delegating readers, which broke its serialization. `subpart`
-        # keeps reading the CEN object, as it did before.
-        def delegate_target
-          target = adopted
-          if target.is_a?(::Pubid::CenCenelec::Identifiers::AdoptedEuropeanNorm)
-            target.adopted
-          else
-            target
-          end
-        end
       end
     end
   end

data/lib/pubid/bsi/identifiers/adopted_international_standard.rb

@@ -7,8 +7,11 @@ module Pubid
       # Example: "BS ISO 8601:2019" where ISO 8601:2019 is an ISO identifier object
       # Example: "BS IEC 62600:2020" where IEC 62600:2020 is an IEC identifier object
       class AdoptedInternationalStandard < BritishStandard
-        # The adopted ISO/IEC identifier object
-        attribute :adopted, ::Pubid::Identifier, polymorphic: true
+        include RootIdentity
+
+        # The adopted ISO/IEC document, under the uniform parent accessor.
+        # `#root` and `#base_document` are inherited and walk it.
+        attribute :base, ::Pubid::Identifier, polymorphic: true
         attribute :edition, :string
         attribute :translation_lang, :string
         attribute :translation_upper, :string
@@ -26,26 +29,6 @@ module Pubid
           nil
         end
 
-        # Delegate common methods to adopted identifier
-        def number
-          adopted&.number
-        end
-
-        def year
-          adopted&.year if adopted&.methods&.include?(:year)
-        end
-
-        def date
-          adopted&.date if adopted&.methods&.include?(:date)
-        end
-
-        def parts
-          adopted&.parts if adopted&.methods&.include?(:parts)
-        end
-
-        def part
-          adopted&.part if adopted&.methods&.include?(:part)
-        end
       end
     end
   end