pubid 2.0.0.pre.alpha.11 → 2.0.0.pre.alpha.13

data/lib/pubid/gb/CLAUDE.md

@@ -0,0 +1,140 @@
+# GB (Chinese Standard) flavor notes
+
+`Pubid::Gb` covers national (`GB`), confidential national (`GBn`),
+sector/industry (`JB`, `HB`, `NY`, …) and social-group (`T/{ORG}`) Chinese
+standards. The mandate category follows a slash: `T` (recommended), `Z`
+(guideline), or nothing (mandatory).
+
+## A flavor `key_value` block REPLACES the base maps — list every attribute
+
+`Pubid::Gb::Identifier` declared its own `key_value` block and mapped
+`publisher_code`, `mandate`, `number`, `part` and `all_parts` — but not
+`date`. lutaml does not merge such a block with the maps of
+`::Pubid::Identifier`; it replaces them. So `to_hash` silently dropped the
+publication year of **every** dated GB identifier:
+
+```ruby
+id = Pubid::Gb::Identifier.parse("GB/T 20223-2006")
+id.to_s                                            # => "GB/T 20223-2006"
+id.year                                            # => "2006"
+id.to_hash                                         # no year at all
+Pubid::Gb::Identifier.from_hash(id.to_hash).to_s   # => "GB/T 20223"
+```
+
+The year survived `to_s`, `exclude` and `matches?`, so nothing in the flavor's
+own behaviour looked wrong. Only `from_hash(to_hash) == parse` saw it — the
+silent failure mode this repository records elsewhere: `#matches?` is
+`exclude(*ignore) == other.exclude(*ignore)`, so a parsed reference never
+matched a `from_hash`-ed index row, and the lookup returned nothing with no
+error. Two editions of one document (`GB/T 20223-2006` and `GB/T 20223-2014`)
+also collapsed onto one hash.
+
+The fix is one line — `map "date", to: :date` — because the shared flat-scalar
+rules do the rest: `flatten_scalar_components` (in `Identifier#to_hash`) writes
+a bare `"year" => "2006"` instead of a nested `date` component, and
+`inflate_scalar_components` reads it back. GB declares no `year` attribute, so
+the `date` → `year` rename applies.
+
+```ruby
+Pubid::Gb::Identifier.parse("GB/T 20223-2006").to_hash
+# => {"_type" => "pubid:gb:standard", "publisher_code" => "GB",
+#     "mandate" => "T", "number" => "20223", "year" => "2006"}
+```
+
+**Lesson for any flavor with its own `key_value` block**: an attribute absent
+from the block does not serialize. Assert `from_hash(id.to_hash) == id`, not
+only `to_s` and `to_hash` — the two shapes that were already correct here.
+
+GB publishes no `relaton-data-gb` index, so no re-crawl follows.
+
+## `GBn` — a lowercase letter inside the publisher token
+
+`GBn` is the confidential national series, and the only one of the 67 prefixes
+the relaton GB flavor carries that did not parse. The publisher rule accepted
+`[A-Z]{1,3}`, which consumed `GB` and then stopped at the `n`.
+
+A PEG takes the first branch that matches and does not backtrack into the
+alternatives, so the `str("GBn")` branch comes **before** the uppercase-only
+branch in `rule(:publisher_code)`. `GBn`, `GBn/T` and `GBn/Z` now parse, and
+`GBn GBn/T GBn/Z` are in `PREFIXES`, so `Pubid.parse` routes them.
+
+All 67 relaton prefixes now round-trip a dated identifier.
+
+## Decision: the em dash normalizes to an ASCII hyphen
+
+Chinese portals print an em dash before the year (`T/ZS 0467—2023`). The parser
+accepts both spellings and the renderer prints an ASCII hyphen:
+
+```ruby
+Pubid::Gb::Identifier.parse("T/ZS 0467—2023").to_s   # => "T/ZS 0467-2023"
+```
+
+This is deliberate, not a defect. The two spellings give **equal** identifiers,
+so a reference in either form matches the document. The alternative — a stored
+separator attribute, the CIE `date_separator` shape — would make the two
+spellings unequal and would need an `exclude` override. The relaton fixture
+`spec/gb/fixtures/tgzaepi_001_2018.xml` records the em-dash form and is the one
+place that must follow this decision.
+
+## The series code lives in the inherited `publisher`
+
+`GB`, `JB`, `GBn` and `T/GZAEPI` are stored in the `publisher` attribute
+inherited from `::Pubid::Identifier`, a `Components::Publisher`. The flavor had
+its own `publisher_code` string beside it while the inherited attribute stayed
+nil, so two attributes described one value and the shared code that reads
+`publisher` saw nothing.
+
+The component serializes as a bare scalar, because the class adds itself to the
+flat-scalar table — the CEN/CENELEC precedent, and for GB's own classes only:
+
+```ruby
+Pubid::Gb::Identifier.flat_scalar_components   # => {..., publisher: "publisher"}
+Pubid::Gb::Identifier.flat_scalar_fields       # => {..., publisher: :body}
+```
+
+```ruby
+{"_type" => "pubid:gb:standard", "publisher" => "GB",
+ "mandate" => "T", "number" => "20223", "year" => "2006"}
+```
+
+**The URN gained the series, which repairs a collision.** `GB 20223-2006` and
+`GBn 20223-2006` are two documents and shared `urn:gb:20223:2006`; they now
+give `urn:gb:gb:20223:2006` and `urn:gb:gbn:20223:2006`. The shared URN
+generator lowercases the body on its own. The MR slug follows (`gb.20223.2006`,
+`gbn.20223.2006`) and sanitizes the slash of a social-group code by itself
+(`T/GZAEPI` → `t-gzaepi.001.2018`), so GB does not join the IEEE slash ledger.
+Annotated rendering gained a `publisher` span for free.
+
+**Note the parse-tree key keeps its name.** `rule(:publisher_code)` in the
+parser still captures `:publisher_code`; parse-tree keys and attribute names
+are different namespaces (the ASHRAE landmine). Only the attribute moved.
+
+## Known gaps
+
+`spec/pubid/gb/fixtures_spec.rb` now reads `spec/fixtures/gb/`, which nothing
+read before (the `ten-dead-fixture-specs` class). It carries a tripwire example
+asserting both globs are non-empty, because a wrong glob reports 0 examples
+instead of a failure. GB has no `identifiers/full/identifiers.txt`, so the
+fixtures are hand-written and `rake validation:classify[gb]` does not drive
+them; the reader accepts both the plain and the generated line shapes.
+
+The URN carries the series, the number and the year, but **not the mandate**:
+`GB 20223-2006` and `GB/T 20223-2006` both give `urn:gb:gb:20223:2006`, and
+their MR slugs are equal too. The mandatory and the recommended standard are
+two documents, so this is a real collision, narrower than the one the series
+repaired. There is also no `Pubid::Gb::UrnParser`, so a GB URN cannot be read
+back. Nothing consumes a GB URN today, so both are recorded, not fixed.
+
+## Not supported (deliberately)
+
+These forms do not parse. Each is outside what the relaton GB flavor supports
+today:
+
+| form | what it is |
+|---|---|
+| `DB11/T 123-2020`, `DB37 1234-2020` | local standards; a province code follows `DB` |
+| `Q/SY 123-2020` | enterprise standard |
+| `GB/T 1.1-2020/XG1-2021` | amendment sheet (修改单) |
+
+`PREFIXES` lists bare `DB`, `DB/T` and `DB/Z`, so the province-numbered form
+was intended but is not parsed.

data/lib/pubid/gb/builder.rb

@@ -6,31 +6,39 @@ module Pubid
     #
     # The parser captures the publisher code verbatim (which may already
     # include the "/T" or "/Z" suffix). The builder normalizes: if the
-    # suffix is in the publisher_code string, it's split out into the
-    # separate +mandate+ attribute so the renderer can recompose either
-    # the inline or split form.
+    # suffix is in the code, it is split out into the separate +mandate+
+    # attribute so the renderer can recompose either the inline or split
+    # form. The code itself goes into the inherited +publisher+ component.
     class Builder
       def self.build(parsed_data)
         new.build(parsed_data)
       end
 
       def build(data)
-        publisher_code, mandate = split_mandate(data[:publisher_code].to_s)
+        code, mandate = split_mandate(data[:publisher_code].to_s)
 
-        mandate ||= data[:mandate]&.to_s
-
-        Identifiers::Standard.new(
-          publisher_code: publisher_code,
-          mandate: mandate,
+        identifier = Identifiers::Standard.new(
+          publisher: ::Pubid::Components::Publisher.new(body: code),
+          mandate: mandate || data[:mandate]&.to_s,
           number: data[:number].to_s,
           part: data[:part]&.to_s,
-          date: data[:year] ? ::Pubid::Components::Date.new(year: data[:year].to_s) : nil,
-          all_parts: !data[:all_parts].to_s.empty?,
+          date: date_for(data[:year]),
         )
+
+        # "(all parts)" names every part of the document, so it wraps the
+        # document, which holds no mark itself.
+        data[:all_parts].to_s.empty? ? identifier : identifier.to_all_parts
       end
 
       private
 
+      # The publication year, or nil for a partial reference.
+      def date_for(year)
+        return nil unless year
+
+        ::Pubid::Components::Date.new(year: year.to_s)
+      end
+
       # If the publisher code carries an inline /T or /Z suffix, split it off
       # and return the cleaned code + extracted mandate.
       def split_mandate(code)
@@ -43,3 +51,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Gb::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/gb/identifier.rb

@@ -7,9 +7,16 @@ module Pubid
     # descend from this class, so a parsed GB id is always an instance of
     # Pubid::Gb::Identifier.
     class Identifier < ::Pubid::Identifier
-      # The issuing body code as printed, e.g. "GB", "JB", "T/GZAEPI".
-      # Always non-empty for a valid identifier.
-      attribute :publisher_code, :string
+      # The all-parts identifier of this flavor.
+      def self.all_parts_class
+        Identifiers::AllParts
+      end
+
+      # The issuing body code as printed — "GB", "JB", "GBn", "T/GZAEPI" —
+      # lives in the `publisher` attribute inherited from ::Pubid::Identifier.
+      # The flat-scalar hooks below serialize it as a bare string, and the
+      # shared URN generator renders it lowercase, so the series is part of
+      # the URN identity (GB 20223 and GBn 20223 are two documents).
 
       # Mandate category: "T" (recommended), "Z" (guideline), or nil
       # (mandatory). Carried after the "/" in the printed form.
@@ -23,25 +30,39 @@ module Pubid
       # uses the dotted form (e.g. "5606.1" => number "5606", part "1").
       attribute :part, :string
 
-      # All-parts flag — true for "GB/T 5606 (all parts)" forms.
-      attribute :all_parts, :boolean, default: -> { false }
 
       # Polymorphic type map for lutaml key_value (de)serialization.
       GB_TYPE_MAP = {
         "pubid:gb:standard" => "Pubid::Gb::Identifiers::Standard",
       }.freeze
 
+      # This block REPLACES the maps of ::Pubid::Identifier, so every
+      # attribute the flavor uses must appear here — "date" included, or the
+      # publication year is lost in to_hash. The shared flat-scalar rules
+      # (Identifier#to_hash / .from_hash) write it as a bare "year" scalar.
       key_value do
         map "_type", to: :_type, polymorphic_map: GB_TYPE_MAP
-        map "publisher_code", to: :publisher_code
+        map "publisher", to: :publisher
         map "mandate", to: :mandate
         map "number", to: :number
         map "part", to: :part
-        map "all_parts", to: :all_parts, render_default: false
+        map "date", to: :date
       end
 
       PUBLISHER = "CN"
 
+      # Serialize `publisher` as a bare string instead of a nested
+      # {"body" => "GB"}, the CEN/CENELEC precedent. The entry is added for
+      # GB's own classes only: a shared entry would change the wire format of
+      # every flavor that publishes an index.
+      def self.flat_scalar_components
+        super.merge(publisher: "publisher")
+      end
+
+      def self.flat_scalar_fields
+        super.merge(publisher: :body)
+      end
+
       def to_s(**opts)
         render(format: :human, **opts)
       end

data/lib/pubid/gb/identifiers/all_parts.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gb
+    module Identifiers
+      # Every part of one GB document: "GB/T 5606 (all parts)".
+      class AllParts < ::Pubid::Gb::Identifier
+        include ::Pubid::AllParts
+
+        # The document URN; GB and IDF mark no series in the URN.
+        def to_urn
+          identity.to_urn
+        end
+      end
+    end
+  end
+end

data/lib/pubid/gb/identifiers.rb

@@ -3,6 +3,7 @@
 module Pubid
   module Gb
     module Identifiers
+      autoload :AllParts, "#{__dir__}/identifiers/all_parts"
       autoload :Standard, "#{__dir__}/identifiers/standard"
     end
   end

data/lib/pubid/gb/parser.rb

@@ -25,6 +25,10 @@ module Pubid
       rule(:publisher_code) do
         # Social-group form: "T/" then 2+ uppercase letters/digits.
         (str("T/") >> match("[A-Z0-9]").repeat(1)).as(:publisher_code) |
+          # Confidential national series. The lowercase "n" is part of the
+          # code, so it comes before the uppercase-only rule below: a PEG
+          # takes the first branch that matches and does not backtrack.
+          (str("GBn") >> (str("/T") | str("/Z")).maybe).as(:publisher_code) |
           # Standard form: 1-3 letters, optional slash-T-or-Z.
           (match("[A-Z]").repeat(1, 3) >>
             (str("/T") | str("/Z")).maybe).as(:publisher_code)

data/lib/pubid/gb/renderer.rb

@@ -8,19 +8,19 @@ module Pubid
     #   "GB/T 20223-2006"
     #   "GB/T 5606.1-2004"
     #   "GB/T 5606 (all parts)"
-    #   "T/GZAEPI 001—2018"     (social-group form, em-dash year)
+    #   "T/GZAEPI 001-2018"     (social-group form; an em-dash year
+    #                            separator in the input renders as a hyphen)
     class Renderer < ::Pubid::Renderers::Base
       def render(**_opts)
         parts = [publisher_portion, " #{number_portion}"]
-        parts << " (all parts)" if @id.all_parts
         parts.join
       end
 
       private
 
       def publisher_portion
-        code = @id.publisher_code.to_s
-        code += "/#{@id.mandate}" if @id.mandate && !@id.publisher_code.include?("/")
+        code = @id.publisher.to_s
+        code += "/#{@id.mandate}" if @id.mandate && !code.include?("/")
         code
       end
 

data/lib/pubid/gb.rb

@@ -17,6 +17,7 @@ module Pubid
     # "GB" comes first so PrefixesSupport's longest-match wins.
     PREFIXES = %w[
       GB GB/T GB/Z
+      GBn GBn/T GBn/Z
       DB DB/T DB/Z
       QB QB/T
       ZB ZB/T

data/lib/pubid/gost/CLAUDE.md

@@ -0,0 +1,64 @@
+# GOST flavor notes
+
+Foreign-adoption routing: the slash-attached prefix boundary that let another
+flavor win the routing race.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/gost/` or `spec/pubid/gost/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+## Foreign-adoption routing must use a token-boundary prefix check, not a literal-space check
+
+`Gost::Builder#parse_foreign` (`lib/pubid/gost/builder.rb`) resolves the
+foreign standard a GOST document adopts (`"GOST 58904-2020/ISO/TR
+25901-1:2016"` → the adopted `"ISO/TR 25901-1:2016"`) by routing through
+`Pubid.prefix_flavors` first — the same "registered prefix, not load order"
+mechanism the earlier `gost-adoption-prefix-routing` fix introduced for
+`"GOST 1437-2024 (ASTM D129-18)"` — and falling back to an exhaustive,
+alphabetically-sorted try-every-flavor loop only when no registered prefix
+matches.
+
+`prefix_owner`'s boundary check used to require a **literal space** after the
+matched prefix (`raw.start_with?("#{p} ")`). That misses a form where the
+type token is attached to the publisher with a **slash** instead of a space —
+`"ISO/TR 25901-1:2016"`, `"ISO/TS 10303-1:2014"` — because the character
+after `"ISO"` is `/`, not a space. Those strings therefore matched no
+registered owner and fell through to the exhaustive fallback loop, racing
+every registered flavor's grammar alphabetically.
+
+**The race was real, not theoretical: `Pubid::Iec`'s own grammar also accepts
+a bare `"ISO/TR 25901-1:2016"`** (as its own identifier, not as a delegation
+to ISO), and renders it `"ISO TR 25901-1:2016"` — a space, IEC's own
+convention, not ISO's. `Pubid::Bsi` also accepts the string and correctly
+delegates to `Pubid::Iso::Identifiers::TechnicalReport`, and normally wins the
+race because `"bsi"` sorts alphabetically before `"iec"` — which is exactly
+why the wrong render (`GOST R 58904-2020/ISO TR 25901-1:2016` instead of
+`.../ISO/TR 25901-1:2016`) was rare and reproduced only intermittently, and
+only under full-suite load (hand-off
+`metanorma__pubid__gost-idt-order-dependent-render.md`; the hand-off chased
+GC/allocation timing and `RenderingContext` memoization as candidate causes —
+neither was it, and neither needed to be pinned down, since routing this
+deterministically by prefix removes the race regardless of what let `bsi`
+occasionally lose it).
+
+**Fix**: `prefix_owner` now uses the same token-boundary rule the top-level
+router already uses (`Pubid.prefix_match?` in `lib/pubid.rb` — a non-word
+character, not specifically a space, ends the prefix). That method used to be
+`@api private`; it is now public for exactly this reason — a second,
+hand-copied boundary check in `Gost::Builder` would be the same
+duplicated-logic-drifts-out-of-sync hazard this file documents elsewhere for
+other flavors (found in code review, not the first pass: the initial fix
+duplicated the regex locally instead of calling the shared method). **Do
+not** re-duplicate this boundary check in a flavor's own builder; call
+`::Pubid.prefix_match?(string, prefix)`.
+
+**Not affected**: a jointly-owned prefix (`"ISO/IEC"`, `"ISO/IEC TR"`) already
+falls through to the exhaustive fallback by design (`owners.one?` is false),
+and every owner renders it identically — verified for both the bare and the
+type-attached compound forms. Only the single-owner, slash-attached-type
+shape (`"ISO/TR"`, `"ISO/TS"`, and by the same rule `"IEC/TR"` etc.) was
+broken.
+
+Locked by `spec/pubid/gost/foreign_adoption_routing_spec.rb`, which includes
+a deterministic reproduction of the race (not a reliance on catching the rare
+full-suite failure): it temporarily `Registry.unregister(:bsi)`s the usual
+race winner and asserts routing still resolves to `Pubid::Iso` correctly —
+proving the fix is prefix routing, not a lucky alphabetical ordering.

data/lib/pubid/gost/builder.rb

@@ -166,7 +166,7 @@ module Pubid
       def prefix_owner(raw)
         index = ::Pubid.prefix_flavors
         match = index.keys
-                   .select { |p| raw.start_with?("#{p} ") || raw == p }
+                   .select { |p| ::Pubid.prefix_match?(raw, p) }
                    .max_by(&:length)
         return nil unless match
 
@@ -183,3 +183,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Gost::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/gost/identifier.rb

@@ -23,6 +23,11 @@ module Pubid
       attribute :number,      :string
       attribute :year,        :string
 
+      # A nil `copublisher` means GOST alone: `GOST R 27001` is not
+      # `GOST R ISO/IEC 27001`, which is an adoption of another body's
+      # document.
+      subset_strict :copublisher
+
       GOST_TYPE_MAP = {
         "pubid:gost:interstate-standard" => "Pubid::Gost::Identifiers::InterstateStandard",
         "pubid:gost:national-standard"   => "Pubid::Gost::Identifiers::NationalStandard",

data/lib/pubid/iala/CLAUDE.md

@@ -0,0 +1,82 @@
+# IALA flavor notes
+
+IALA (International Organization for Marine Aids to Navigation)
+publication identifiers and their MRN URNs.
+
+Read this before you change `lib/pubid/iala/` or `spec/pubid/iala/`. The
+root `CLAUDE.md` keeps the cross-flavor contract that every flavor
+obeys.
+
+## Identifier space
+
+Every IALA publication carries a coded reference: a series prefix
+followed by a number whose shape varies per series.
+
+| Series | Type | Numbering | Example |
+|--------|------|-----------|---------|
+| S | Standard | 4 digits, zero-padded | `IALA S1070 Ed 2.0` |
+| R | Recommendation | 4 digits, zero-padded | `IALA R0126 Ed 2.0` |
+| G | Guideline | 4 digits, zero-padded | `IALA G1015 Ed 2.2` |
+| C | Model Course | 4 digits + `-` part | `IALA C0103-1 Ed 3.0` |
+| M | Manual (planned) | 4 digits, zero-padded | `IALA M0001 Ed 9.0` |
+| A | Advice | dashed, no edition in the corpus | `IALA A12-01` |
+| GA | General Assembly resolution | dotted, each segment 2 digits | `IALA GA01.01` |
+| L | Letter | dotted + dashed, verbatim | `IALA L2.1.11 Ed 2` |
+| X | Report (reserved) | 4 digits | `IALA X0123` |
+| P | Resolution/Council publication (reserved) | 4 digits | `IALA P0123` |
+| — | Annex wrapper over any base | bare or lettered | `IALA G1128 ANNEX A Ed 1.6` |
+
+The Annex class has no prefix of its own: it wraps a base identifier of
+another series and preserves the annex marker case (`Annex` vs `ANNEX`).
+X and P are reserved for future numbered series — today's reports and
+Council publications carry no code; unnumbered report/symposium
+documents exist in relaton-data-iala only as slug-form bibliographic
+records, deliberately outside this identifier space.
+
+## MRN URN scheme
+
+IALA publications are named in the `mrn` URN tree as assigning
+authority `iala`, sub-namespace `pub`:
+
+```
+urn:mrn:iala:pub:<code>[:annex[-<letter>]][:ed<x.x>][:<lang>]
+```
+
+- `<code>` — the lowercased series prefix + number (`s1070`,
+  `c0103-1`, `ga01.01`, `l2.1.11`, `a12-01`, and the reserved `x0123`,
+  `p0123`)
+- `annex` / `annex-<letter>` — the Annex wrapper (lettered form for
+  `ANNEX A`-style, bare for `Annex` without a letter)
+- `ed<x.x>` — edition, lowercase marker, no separator dot
+- `<lang>` — single lowercase language letter
+
+The authoritative pattern for published documents is the IALA Style
+Guide (G1115, Ed 1.0 January 2021) document-reference clause:
+`urn:mrn:iala:pub:[p][nnnn]` with p ∈ {S, R, G, C} — printed on the
+cover and footers. URNs for the other series (M, A, GA, L, X, P) are a
+pattern-consistent extension: no such URN has been observed in a
+published document yet, but every series round-trips through the same
+generator/parser pair.
+
+## Parsing and normalization
+
+- The umbrella `Pubid.parse` routes URN-form input by assigning
+  authority (`urn:mrn:iala:…` → the IALA flavor), not by the literal
+  `mrn` namespace; unknown MRN authorities fail loudly.
+- `Pubid::Iala.parse` dispatches URN-form input to `UrnParser` via
+  `FormatDetector`, so both entry points accept both forms.
+- The edition marker matches case-insensitively with an optional
+  separator dot. Both malformed variants printed in the published R1026
+  PDF (`…r1026:Ed1.0`, `…r1026:ed.1.0`) parse and normalize to the
+  canonical `ed1.0`.
+- Short inputs are zero-padded to the canonical form (`M1` → `M0001`,
+  `GA1.1` → `GA01.01`); L-series numbering is preserved verbatim.
+
+## Conformance
+
+Ground truth lives in the shared suite
+(pubid/pubid-testsuite `reference-docs/iala`): 701 coded identifiers
+from relaton-data-iala primary docidentifiers plus the 15 MRN URNs
+transcribed from the published PDFs in metanorma/mn-samples-iala
+`reference-docs/` (including the two malformed R1026 spellings, kept
+byte-identical as normalization aliases).

data/lib/pubid/iala/builder.rb

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

data/lib/pubid/iana/CLAUDE.md

@@ -0,0 +1,7 @@
+# IANA flavor notes
+
+IANA registry slugs as the index key.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/iana/` or `spec/pubid/iana/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **IANA registries have no number — the top-level slug IS the index key**: an IANA identifier is a hierarchical registry slug, `IANA <registry>[/<sub-registry>]`, capped at one slash. Verified against all 3405 published `relaton-data-iana` rows: two shapes only (655 top registries, 2750 with one sub-registry, **0** with ≥2 slashes), charset exactly `[A-Za-z0-9._-]` + `/` (matching `Parser#slug` verbatim), and **1425 ids contain digits but ZERO have a separable numeric component** — digits are always glued inside a slug token (`sip-parameters/sip-parameters-13`, `idna-tables-11.0.0`, `smi-numbers/smi-numbers-1.3.6.1.2.1.198.4`, `isis-tlv-codepoints/tlv-149-150`, `_6tisch`). There is no ISO-style `<base>-<part>` to extract. So, exactly as for an Internet-Draft slug, **the slug itself is the number**: `attribute :number, :string` holds the **top-level** registry slug and `sub_registry` stays its own key, so a registry and all of its sub-registries **cluster into one bucket** (655 buckets, median 3, max 73 — `pcep`) — the analogue of a draft clustering with its versions. Before this, `root.number.to_s` was `""` for **every** IANA id, which silently defeats relaton-index's bsearch narrowing (`Type#get_id_number` reads `id.number.to_s`), and `to_mr_string` was `""` for every id, so all 3405 collided on the MR slug — and `to_slug` is used as a **filename**. **The attribute is declared on the concrete leaf `Identifiers::Registry`, NEVER on `Pubid::Iana::Identifier`** (which the leaf inherits from): it redefines the parent `::Pubid::Identifier`'s `attribute :number, Components::Code`, and on an inherited-from class that resolves nondeterministically under multi-flavor load — the IEEE/IETF landmine, so `spec/pubid/iana/root_number_spec.rb` only means anything under the **full `rake` suite**. No `#number` *method* is defined (it would collide with lutaml's generated accessor). **`registry` is no longer a serialized key** — it was the same string as `number`, so it is now a plain derived reader `def registry; number; end` on the base (safe: no lutaml accessor competes with a name that is not an attribute; the `Pubid::Ietf::Identifiers::Bcp#series` precedent), and the leaf's `key_value` block (`number`) is **merged** by lutaml with the base's (`_type` + `sub_registry`). Serialized vocabulary is thus `{_type, number}` / `{_type, number, sub_registry}`. **There is no alias**, so a pre-`number` row deserializes with a nil `number` and *no error at all* (lutaml ignores unknown keys, and relaton's `FileIO#id_supported?` skips its round-trip check for concrete subclasses — every IANA id is an `Identifiers::Registry`). Rendering is therefore the loud failure: `Renderer#require_number!` raises `ArgumentError` rather than emitting a bare `"IANA "`. Nothing published needs migrating today — `relaton-iana` has no pubid dependency and still uses the string-keyed `index-v1`. **MR**: the flavor supplies `mr_publisher` (`"iana"` — IANA keeps its publisher as the `PUBLISHER` constant, not a lutaml attribute, so the base's `publisher&.to_s` yields nil) and `mr_number_with_part` (`[number, sub_registry].compact.join(".").downcase`); verified over the corpus to give 3405 **distinct** slugs inside the documented `[a-z0-9._-]` charset. Caveat: IANA slugs legitimately contain `_`, which is MR's supplement separator, so an IANA MR is **not** re-parseable by `Pubid::Parsers::MrString` — uniqueness and filename-safety are what it buys. **URN is unchanged** (`urn:iana:<registry>[:<sub_registry>]`; the generator just reads `number` instead). Locked by `spec/pubid/iana/{root_number,mr_string}_spec.rb`, the opt-in `corpus_round_trip_spec.rb` (`PUBID_IANA_CORPUS=<dir with relaton-data-iana> bundle exec rake test:corpus_iana`, ~3s, all 3405 rows: parse + byte-exact `to_s` + `from_hash(to_hash)` fidelity + non-empty `root.number` + MR uniqueness), and IANA rows added to `uniform_identifier_handle_spec`/`redos_guard_spec`, which it was missing from. **Note**: the cross-flavor "every registered flavor has a non-empty MR" block in `spec/pubid/mr_string_spec.rb` is a hand-picked 10-flavor sample, not registry-driven, which is why the empty-MR gap went unnoticed — making it registry-driven would likely surface the same gap in other slug-only flavors (XSF, OGC, adobe, PLATEAU) and is deliberately left as separate work. (hand-off: relaton-iana pubid-index-v2-readiness.)

data/lib/pubid/iana/builder.rb

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