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

data/lib/pubid/iso/identifiers/tc_document.rb

@@ -6,18 +6,15 @@ module Pubid
       # Technical Committee Document
       # Format: TC 184/SC 4/WG 3 N 123, JTC 1 N 456, TC 184 N 100
       class TcDocument < Identifier
-        # TC type (TC, JTC, PC, IT, etc.)
-        attribute :tc_type, ::Pubid::Components::Code
-        # TC number
-        attribute :tc_number, ::Pubid::Components::Code
-        # SC type
-        attribute :sc_type, ::Pubid::Components::Code
-        # SC number
-        attribute :sc_number, ::Pubid::Components::Code
-        # WG type
-        attribute :wg_type, ::Pubid::Components::Code
-        # WG number
-        attribute :wg_number, ::Pubid::Components::Code
+        # The committee structure: plain strings ("TC", "184", "SC", "4").
+        # Each held a Components::Code carrying nothing but `value`, and the
+        # serialized form was already the bare scalar.
+        attribute :tc_type, :string
+        attribute :tc_number, :string
+        attribute :sc_type, :string
+        attribute :sc_number, :string
+        attribute :wg_type, :string
+        attribute :wg_number, :string
 
         # TC types from ISO system
         TC_TYPES = %w[TC JTC PC IT CAB CASCO COPOLCO COUNCIL CPSG CS DEVCO GA
@@ -33,33 +30,21 @@ module Pubid
         # TC documents don't use typed stages like other identifiers
         TYPED_STAGES = [].freeze
 
-        # Serialize the committee structure (all plain-string Codes) on top of
-        # the inherited ISO mapping; TC documents have no stage.
+        # Serialize the committee structure on top of the inherited ISO
+        # mapping; TC documents have no stage. The attributes are plain
+        # strings, so lutaml needs no converter (the ETSI/OIML shape).
         key_value do
-          map "tc_type", with: { to: :tc_type_to_kv, from: :tc_type_from_kv }
-          map "tc_number", with: { to: :tc_number_to_kv, from: :tc_number_from_kv }
-          map "sc_type", with: { to: :sc_type_to_kv, from: :sc_type_from_kv }
-          map "sc_number", with: { to: :sc_number_to_kv, from: :sc_number_from_kv }
-          map "wg_type", with: { to: :wg_type_to_kv, from: :wg_type_from_kv }
-          map "wg_number", with: { to: :wg_number_to_kv, from: :wg_number_from_kv }
+          map "tc_type", to: :tc_type
+          map "tc_number", to: :tc_number
+          map "sc_type", to: :sc_type
+          map "sc_number", to: :sc_number
+          map "wg_type", to: :wg_type
+          map "wg_number", to: :wg_number
         end
 
         # TC documents have no stage; suppress the inherited stage emission.
         def stage_to_kv(_model, _doc); end
 
-        def tc_type_to_kv(m, doc) = emit_code(doc, "tc_type", m.tc_type)
-        def tc_type_from_kv(m, v) = m.tc_type = build_code(v)
-        def tc_number_to_kv(m, doc) = emit_code(doc, "tc_number", m.tc_number)
-        def tc_number_from_kv(m, v) = m.tc_number = build_code(v)
-        def sc_type_to_kv(m, doc) = emit_code(doc, "sc_type", m.sc_type)
-        def sc_type_from_kv(m, v) = m.sc_type = build_code(v)
-        def sc_number_to_kv(m, doc) = emit_code(doc, "sc_number", m.sc_number)
-        def sc_number_from_kv(m, v) = m.sc_number = build_code(v)
-        def wg_type_to_kv(m, doc) = emit_code(doc, "wg_type", m.wg_type)
-        def wg_type_from_kv(m, v) = m.wg_type = build_code(v)
-        def wg_number_to_kv(m, doc) = emit_code(doc, "wg_number", m.wg_number)
-        def wg_number_from_kv(m, v) = m.wg_number = build_code(v)
-
         def self.type
           { key: :tc,
             web: :tc_document, title: "Technical Committee Document", short: "TC" }
@@ -73,23 +58,23 @@ module Pubid
           result = publisher.to_s if publisher
 
           # Add TC type and number
-          result += "/#{tc_type.render} " if tc_type&.value
-          result += tc_number.render.to_s if tc_number&.value
+          result += "/#{tc_type} " unless tc_type.to_s.empty?
+          result += tc_number.to_s unless tc_number.to_s.empty?
 
           # Add SC type and number
-          if sc_type&.value && sc_number&.value
-            result += "/#{sc_type.render} "
-            result += sc_number.render.to_s
+          unless sc_type.to_s.empty? || sc_number.to_s.empty?
+            result += "/#{sc_type} "
+            result += sc_number.to_s
           end
 
           # Add WG type and number
-          if wg_type&.value && wg_number&.value
-            result += "/#{wg_type.render} "
-            result += wg_number.render.to_s
+          unless wg_type.to_s.empty? || wg_number.to_s.empty?
+            result += "/#{wg_type} "
+            result += wg_number.to_s
           end
 
           # Add document number
-          result += " N #{number.render}" if number&.value
+          result += " N #{number}" unless number.to_s.empty?
 
           # Add year if present
           result += ":#{date.render}" if date&.year
@@ -105,16 +90,16 @@ module Pubid
           parts << publisher.render(context: urn_ctx) if publisher
 
           # Add TC
-          parts << "tc:#{tc_number.render(context: urn_ctx)}" if tc_number&.value
+          parts << "tc:#{tc_number}" unless tc_number.to_s.empty?
 
           # Add SC
-          parts << "sc-#{sc_number.render(context: urn_ctx)}" if sc_number&.value
+          parts << "sc-#{sc_number}" unless sc_number.to_s.empty?
 
           # Add WG
-          parts << "wg-#{wg_number.render(context: urn_ctx)}" if wg_number&.value
+          parts << "wg-#{wg_number}" unless wg_number.to_s.empty?
 
           # Add document number
-          parts << number.render(context: urn_ctx) if number&.value
+          parts << number.to_s unless number.to_s.empty?
 
           parts.join(":")
         end

data/lib/pubid/iso/identifiers.rb

@@ -4,6 +4,7 @@ module Pubid
   module Iso
     module Identifiers
       autoload :Addendum, "#{__dir__}/identifiers/addendum"
+      autoload :AllParts, "#{__dir__}/identifiers/all_parts"
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :Data, "#{__dir__}/identifiers/data"

data/lib/pubid/iso/normalizer.rb

@@ -73,7 +73,7 @@ module Pubid
 
           addendum = Identifiers::Addendum.new
           addendum.base = base
-          addendum.number = Iso::Components::Code.new(value: supplement_number)
+          addendum.number = supplement_number
           addendum.date = Pubid::Components::Date.new(year: supplement_year) if supplement_year
 
           typed_stage = Pubid::Iso.locate_stage(stage_abbr)

data/lib/pubid/iso/rendering_style.rb

@@ -46,7 +46,6 @@ module Pubid
         end
 
         # All parts notation (if applicable)
-        result << " (all parts)" if identifier.class.attributes.key?(:all_parts) && identifier.all_parts
 
         result
       end

data/lib/pubid/iso/urn_generator.rb

@@ -63,7 +63,7 @@ module Pubid
         parts << originator_component
         type_comp = type_component
         parts << type_comp if type_comp
-        parts << identifier.number.render(context: URN_CONTEXT) if identifier.number
+        parts << identifier.number.to_s if identifier.number
         part_comp = part_component
         parts << part_comp if part_comp
         stage_comp = stage_component
@@ -95,7 +95,7 @@ module Pubid
           parts << base_gen.originator_component
           type_comp = base_gen.type_component
           parts << type_comp if type_comp
-          parts << base_id.number.render(context: URN_CONTEXT) if base_id.number
+          parts << base_id.number.to_s if base_id.number
           part_comp = base_gen.part_component
           parts << part_comp if part_comp
 
@@ -138,13 +138,13 @@ module Pubid
             parts << supp.date.render(context: URN_CONTEXT)
             if supp.number
               if supp.stage_iteration && !supp.is_a?(Pubid::Iso::Identifiers::Supplement)
-                parts << "v#{supp.number.render(context: URN_CONTEXT)}.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
+                parts << "v#{supp.number}.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
               else
-                parts << "v#{supp.number.render(context: URN_CONTEXT)}"
+                parts << "v#{supp.number}"
               end
             end
           else
-            parts << supp.number.render(context: URN_CONTEXT) if supp.number
+            parts << supp.number.to_s if supp.number
             if supp.stage_iteration && !supp.is_a?(Pubid::Iso::Identifiers::Supplement)
               parts << "v1.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
             else
@@ -197,8 +197,8 @@ module Pubid
       def part_component
         return nil unless identifier.part
 
-        result = "-#{identifier.part.render(context: URN_CONTEXT)}"
-        result += "-#{identifier.subpart.render(context: URN_CONTEXT)}" if identifier.subpart
+        result = "-#{identifier.part}"
+        result += "-#{identifier.subpart}" if identifier.subpart
         result
       end
 
@@ -292,13 +292,13 @@ module Pubid
           parts << identifier.date.render(context: URN_CONTEXT)
           if identifier.number
             parts << if identifier.stage_iteration
-                       "v#{identifier.number.render(context: URN_CONTEXT)}.#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
+                       "v#{identifier.number}.#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
                      else
-                       "v#{identifier.number.render(context: URN_CONTEXT)}"
+                       "v#{identifier.number}"
                      end
           end
         else
-          parts << identifier.number.render(context: URN_CONTEXT) if identifier.number
+          parts << identifier.number.to_s if identifier.number
           parts << if identifier.stage_iteration
                      "v1.#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
                    else

data/lib/pubid/iso.rb

@@ -66,7 +66,7 @@ module Pubid
     # @param type [Symbol] the type key (e.g. :is, :tr, :ts, :guide)
     # @param publisher [String, Pubid::Iso::Components::Publisher] primary publisher
     # @param copublishers [Array<String>, Array<Pubid::Components::Publisher>]
-    # @param number [String, Integer, Pubid::Iso::Components::Code]
+    # @param number [String, Integer]
     # @param year [String, Integer, Pubid::Components::Date, nil]
     # @param attrs [Hash] additional identifier attributes
     # @return [Pubid::Iso::Identifier]
@@ -106,10 +106,11 @@ module Pubid
     private_class_method :build_copublishers
 
     # @!visibility private
+    # number/part/subpart are plain strings. A caller that still passes a
+    # Components::Code (another flavor's builder, a hand-built id) is read
+    # through its own #to_s rather than refused.
     def self.build_code(value)
-      return value if value.is_a?(Components::Code)
-
-      Components::Code.new(value: value.to_s)
+      value.to_s
     end
     private_class_method :build_code
 

data/lib/pubid/itu/CLAUDE.md

@@ -0,0 +1,69 @@
+# ITU flavor notes
+
+ITU grammar, versions, annexes, reports and identity surfaces.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/itu/` or `spec/pubid/itu/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **ITU Questions / Handbooks / N-way combined**: `Pubid::Itu` models study-group **Questions** (`Identifiers::Question`, `_type: pubid:itu:question` — numeric `ITU-R 234-1/7:` and letter-series `ITU-R P.3/BL/7`, `ITU-R S.[4/BL/2]:`; the `/BL` segment, brackets and trailing `:` are carried as `has_bl`/`bracketed`/`has_colon` booleans + a `study_group` string, all reconstructed by `render_base`) and **Handbooks** (`Identifiers::Handbook`, `ITU-R 23.HDB`; the `.HDB` marker is implied by `_type`). Parser disambiguation is by what follows a `/`: **digits** → a Question study-group; a **series** (letters) → a combined designation — so the new rules sit before `with_series`/`without_series`. **Combined (joint) recommendations are N-way**: the primary designation stays on the base `series`/`code` (keeps `root.number` non-empty for relaton-index) and each *additional* designation is a `Components::Designation` in `CombinedIdentifier#combined` (one for a dual `G.780/Y.1351`, two+ for a triple `G.780/Y.1351/Z.1362`); the parser's `combined_designation` rule is `repeat(1)`. **`#number` at the root**: ITU stores the document number on `code`, but `Pubid::Itu::Identifier#number` delegates to `code&.number` so `id.root.number.to_s` is the key relaton-index sorts/bsearches on (non-empty for every type). The delegation is serialization-neutral (the flat block maps `number` via `number_to_kv`/`number_from_kv` off `code`, never the inherited `number` attribute); Supplement/Amendment/Corrigendum/Errata keep their own `:string` `number` ordinal (it overrides the reader), and their base document number is reached via `root.number`.
+
+- **ITU `(V##)` versions, labelled annexes, and class-strict supplement `==`**: three ITU-T forms relaton's `relaton-data-itu` crawler needs (~930 data files had no index row because they failed to parse). **(1) `version`** — `ITU-T H.264 (V14) (08/2021)`: a plain **`attribute :version, :string`** on the shared `Pubid::Itu::Identifier` (safe — `::Pubid::Identifier` declares no `version`, so this is a *new* attribute, not the `number`/`stage` retype landmine), fed by the `version_part` rule (`space >> "(V" >> digits >> ")"`) spliced in **immediately before `date_part.maybe`** in all four document rules (`with_series`/`without_series`/`base_with_series`/`base_without_series`) — version always precedes the date in the corpus, and `date_part` requires digits after `(` so the two never compete. Rendered `" (V#{version})"` between code and date by `render_base` **and** by `CombinedIdentifier#to_s` (which overrides `to_s` and does not call `render_base` — miss it and the version is silently dropped on a joint id); mapped in `StandardSerialization`; compared in both `==` overrides. **URN and MR strings stay version-blind by design** (the ITU URN convention defines no version segment), so `(V13)`/`(V14)` share a URN. **(2) Labelled annex** — `ITU-T A.23 Annex A (06/2014)` is its **own** leaf class `Identifiers::AnnexOfRecommendation` (`_type: pubid:itu:annex-of-recommendation`), *not* an extension of `Identifiers::Annex`: that models the structurally different label-less "Annex to ITU OB No. 1000" (prefix rendering + i18n templates) whose `_type` is already persisted in index rows. Shape mirrors `Supplement`: polymorphic `base` + `:string number` (the label — `A`, `F3`, the one-off `C+`) + its own date/language, a minimal `key_value` block (never re-emitting the base's sector/series/code), `render_base` → `"<base> Annex <label>"`, `to_urn` → `"<base urn>:annex:<label>"`, `#root` walking `base` so `root.number` is the annexed document's number. Grammar: `annex_body` wraps the annexed document in **`base.as(:base)`** — load-bearing, because the base may carry its own date (`ITU-T X.692 (2002) Annex E (03/2002)`) and two `date_part`s flattened into one hash would make Parslet silently keep only the last `:year`. `annex_identifier` sits in `rule(:identifier)` **after `supplement_identifier`** (an annex can carry a trailing `Cor.`/`Err.`/`Amd.`, and PEG ordered choice never re-enters once an alternative succeeds) and **before `with_series`** (which would match the `ITU-T A.23` prefix and then fail on the unconsumed ` Annex A`); `supplement_with_base` takes `(annex_body.as(:base) | base.as(:base))` so `ITU-T G.729 Annex B (1996) Cor. 3 (03/2001)` nests annex-inside-supplement. `Builder#build_supplement`'s fallback `Components::Sector.new` is now guarded on `data[:sector]` — an annex base keeps sector/series on *its* base, and the unguarded fallback raised `Invalid sector: `. **(3) `Supplement#==`** now uses **`instance_of?(self.class)`** (so `Suppl. 2` ≠ `Amd 2` ≠ `Cor. 2`, symmetrically — `is_a?` made a Supplement equal an Amendment one-way) and compares `sector`/`series` **only when `base` is nil**. Both halves matter: the series-only form (`ITU-T A Suppl. 2`) holds its whole identity in sector+series, so ignoring them made every series' `Suppl. 2` equal (an index search returned 42 rows, and `eql?`/`hash` collapsed them in a `Set`); but a *based* supplement copies sector/series from its base while the key_value block deliberately does **not** serialize them, so comparing them unconditionally would break `parse(s) == from_hash(parse(s).to_hash)` — the very lookup this fixes. The now-identical `==` overrides on `Amendment`/`Corrigendum`/`Errata` were deleted. `language` is deliberately **not** compared (an index row without a language suffix must still match a reference that has one). Locked by `spec/pubid/itu/identifiers/{version,annex_of_recommendation,supplement}_spec.rb` + rows in `root_number_spec.rb`/`serialization_spec.rb` and the new `spec/fixtures/itu/identifiers/pass/{version,annex_of_recommendation}.txt`. **Rendering/URN/MR consequences of the annex wrapper:** `CombinedIdentifier` had its rendering in `to_s`, which the annex (composing `base.render_base`) bypassed — silently dropping the `/Y.1351` half, so `G.780/Y.1351 Annex A` and `G.780/Z.1362 Annex A` printed identically (and `to_s` is relaton's document number *and* output filename). It now renders in **`render_base`**, with the inherited `to_s` adding the language suffix and common-text twin. The annex's `to_urn` appends its **own date** after the label (`urn:itu:t:A.23:annex:a:06/2014`) — the base's date rides inside `base_urn`, so omitting the annex's would collide editions — and it defines **`mr_supplement_suffix`** (`annex.<label>[.<year>]`, `C+`→`cplus`) so the shared MrString renderer recurses into the annexed document instead of collapsing every annex onto a bare `itu.<date>`. Because the annex keeps sector/series/code on *its* base, `build_supplement` reaches identity through **`base.root`** when the base has none, so a supplement *of* an annex keys like any other supplement. **Version matching semantics:** `version` is in `==`, so a bare `ITU-T H.264` does **not** match `ITU-T H.264 (V14) …` under `ignore: %i[year month]` — version is a *separable trailing component* like ETSI's (`partial_ref_spec` now lists ITU as `omits: %i[date version]`), so callers matching a partial ref must add `:version` to `ignore`; it is deliberately **not** folded into the `:year`→`:date` alias. **Also fixed here:** `spec/pubid/itu/fixtures_spec.rb`'s glob had one `..` too many (repo-root `fixtures/`), so the whole ITU fixture round-trip spec silently iterated an empty file list. **Out of scope at the time, both since fixed:** `ITU-T V.25 ter Annex A (08/1996)` (the space-separated `ter` gap — closed by the code-suffix work below), and `Amendment#to_s`'s missing dot. (hand-off: itu-version-annex-and-supplement-matching.)
+
+- **ITU-T unparseable print forms (the `relaton-data-itu` residue)**: 668 of the 755 unindexed `relaton-data-itu` records were ITU-T `rec_name` spellings the grammar had no rule for; all 668 now parse, render and satisfy relaton's gate (`from_hash(to_hash) == to_hash`), with **zero** change to any of the 20,728 already-indexed ids. **The single most important invariant when touching this area: every new rendering flag is a `:boolean` named for the RARE form with `default: -> { false }`**, because the canonical `to_hash` strips default-valued attributes — a flag named for the common case would add a key to every already-published index row. Ten constructs, grouped by where they live:
+  **(1) Supplement family.** `supplement_type` gained `Add.`/`Add` → the new leaf `Identifiers::Addendum < Supplement` (`_type: pubid:itu:addendum`), and `Builder#build_supplement`'s `case` gained an **`else raise ArgumentError`** — it previously fell through to a nil class and died with `undefined method 'new' for nil` one frame later. The near-identical `to_s` on `Supplement`/`Amendment`/`Corrigendum`/`Errata` collapsed into one **`Supplement#render_supplement(label)`**; each subclass now supplies only its label. `supplement_number` made the space optional (`ITU-T E Suppl.1`, `ITU-T D.211 Suppl.1` → `number_glued`) and the ordinal dotted (`ITU-T M Suppl. 1.1` → `number` is the whole `"1.1"`). `number_glued` is serialized but deliberately **not** in `==` — `Suppl.1` and `Suppl. 1` are one document. `chained_supplement`'s inner alternation gained `supplement_series_only` so a supplement *of* a series-only supplement parses (`ITU-T G Suppl. 39 (2006) Err. 1 (08/2006)`).
+  **(2) `Technical Cor.`** (158 records, the largest bucket — and the one the hand-off mislabelled as a series-code form). A `technical_marker` rule at the **head of `supplement_type`**, not folded into its alternation, so the type token stays the plain `Cor.` the builder's `case` maps; a `technical` boolean on `Corrigendum` renders and compares it. The slash-joined pair `ITU-T X.680 (1994) Amd. 1/Technical Cor. 1 (12/1997)` is a new **`slash_chained_supplement`** rule (a Corrigendum whose `base` is the Amendment) placed **before `supplement_with_base`** in the alternation — that alternative alone matches the `… Amd. 1` prefix and leaves `/Technical Cor. 1 …` unconsumed, which fails the whole parse with no re-entry.
+  **(3) Code suffixes — the highest-blast-radius change, since it fires on *every* recommendation parse.** A shared `code_suffixes` rule (`series_suffix_spaced.maybe >> qualifier_spaced.maybe`) spliced after `code` and **before `combined_suffixes`** (the corpus attaches the primary's suffix before the `/`: `ITU-T D.301 R/F.66`) in all four document rules. It cannot live *inside* `code`, or its leading space would also be offered to ` Suppl.`/` Annex` and have to backtrack out of a rule the wrappers depend on. `Components::Code` gained `series_suffix_spaced` (the spaced `ITU-T E.250 bis` vs the spec-locked glued `X.50bis` of issue #231 — the word itself is stored whitespace-free either way, so the serialized value stays comparable), plus `qualifier` + `qualifier_glued` for the trailing letter (`ITU-T D.200 R`, `ITU-T Q.2931 B`, `ITU-T R.38 A`, glued `ITU-T D.502R`, lowercase `ITU-T I.256.2a`). **Both guards on `qualifier_letter` are load-bearing**: the `A-R`/`a-r` cap keeps it off the `S` of ` Suppl.` and the `V` of a bare ` V2`, and the trailing `match["A-Za-z0-9"].absent?` is what stops ` Amd.`/` Add.`/` Annex A`/` App.`/` Cor.`/` Err.` being read as a qualifier. It cannot collide with `language` (dash-attached) or `date_part`/`version_part` (both need `(` after the space). Because `Code#to_s` can now contain a space, **`Code#compact_s`** (`to_s.delete(" ")`) was added and is what `urn_generator` interpolates — a space is not admissible in a URN segment, and dropping the suffix instead would collapse `D.200` and `D.200 R` onto one URN. The same slots were added inside `combined_designation` (positionally, so the suffix lands on the designation it printed against: `ITU-T D.300 R/E.282 R` sets both, `ITU-T E.211/Q.11 quater` only the last) — which required the parallel edits to `Builder#build_designations` **and** `CombinedIdentifier#combined_to_kv`/`combined_from_kv`, whose row hash is hand-built. Neither spacing flag is in `Code#==`: the two spellings of one number are one document. **`mr_number_with_part` also had to learn both suffixes** (glued to the number, `x-50bis`/`d-200r`) — it read only number/subseries/parts, so every qualified variant collapsed onto its base's MR slug and, worse, `Q.2931 B` and `Q.2931 C` onto each other. This changes the MR string of the handful of pre-existing glued-`bis` ids (`X.50bis`: `itu.t.x-50` → `itu.t.x-50bis`), which is the point — they were wrongly sharing a slug with `X.50`.
+  **(4) Version spellings.** `version_part` gained a bare branch, so `v.1`/`v10`/`V2` join the canonical `(V14)` in the same `version` attribute. This is the **one deliberate non-byte-exact normalisation** — all render as `(V##)` — so those strings live in `version_spec.rb` with explicit expectations and **not** in the byte-exact pass fixtures. Safe against the qualifier rule precisely because `V` is outside its `A-R` cap. relaton can now drop its own `v10` → `(V10)` normalisation.
+  **(5) Appendix.** `Identifiers::AppendixOfRecommendation` (`_type: pubid:itu:appendix-of-recommendation`) mirrors `AnnexOfRecommendation` one-for-one — including wrapping the appendixed document in **`base.as(:base)`** so the base's own date (`ITU-T G.722 (1988) App. IV (11/2006)`) lands a level down instead of colliding, and defining `mr_supplement_suffix` so the shared MR renderer recurses. Its alternation slot is the annex's reasoning verbatim: **after `supplement_identifier`** (an appendix can carry a trailing `Amd.`/`Err.`), **before `with_series`**. Three registrations are easy to miss and all three are needed: the `identifiers.rb` autoload, the `Builder#build` branch, and widening `urn_generator`'s `AnnexOfRecommendation` check — that check exists because a wrapper whose identity sits one level deeper otherwise emits `urn:itu:itu`. A `material` attribute carries the companion-artefact records (`App. II test vectors`, `App. I Software`), and is in the URN so they stay distinct from the appendix itself.
+  **(6) Series groups vs series-code documents — a corpus heuristic, not an ITU rule.** `series_group` (`E-100`, `E100-300`, `G-100`, `Q-500`) is capped at **one** leading letter; `series_code_body` (`EMC-5`, `MES-2`, `QOS-2`, `IMPL-8`, `SEC-QKD`) requires **two or more**. That split is what keeps them from shadowing each other, and it holds across the whole corpus but would misfile a future `AB-100` group or `E-QKD` document — `series_group_spec.rb` locks both sides so a change is visible. `series_group` must be tried **before** `series`, whose greedy non-backtracking `letter.repeat(1,3)` would take the `E` of `E-100` and then fail on the required space with no retry at a shorter length. `series_code_body` is a flat two-token shape (series + dash + alphanumeric number) rather than an optional middle segment, because a greedy `letter.repeat(2)` + optional `-QKD` + required dash fails at end-of-input with no backtracking into the satisfied `.maybe`; it sits **last** in `base` and after `with_series` in `identifier`, where nothing can reach it by accident. The number stays in `code.number` (not `"EMC-5"` in `series`) precisely so **`root.number`** — the key relaton-index bsearches on — is `"5"`/`"QKD"` rather than nil. `series_dash` drives the `-` vs `.` join in `render_base`; the builder's OB check gained a `series_dash.nil?` guard so a hypothetical `ITU-T OB-1` cannot be misrouted into the Operational Bulletin branch. The literal word `series` is its own `series_word` boolean and **cannot** live in the series token, because it also follows a *dotted* code (`ITU-T E.1100 series Suppl. 1`) where folding it in would corrupt the value every index row is keyed on; `Supplement` emits it only when base-less (guarded like `sector`/`series`).
+  **(7) Tail.** `attachment` boolean (`ITU-T H.350 attachment`), `range_end` string (`ITU-T Q.120-Q.139` — no conflict with `parts`, which needs digits after the dash), and `Identifier.parse` now collapses runs of whitespace (`ITU-T D.271  (10/2016)`) **after** the shared `Pubid::MAX_INPUT_LENGTH` guard, never before.
+  **The cross-cutting lesson (three review findings were all this same mistake): an identity-bearing marker must reach ALL THREE identity surfaces — `to_s`, `to_urn` and `to_mr_string` — not just `==`.** A marker that only reaches `==` still lets two distinct documents share a URN and an output slug. So `generate_base_urn` emits `series`/`attachment`/`to-<range_end>` segments and joins a series-code document with its dash (`urn:itu:t:EMC-5:2003`, not the ambiguous `EMC.5`); `generate_supplement_urn`'s base-less branch emits `series` too; and `mr_number_with_part` carries all five. `Builder#build_supplement` copies `series_word` up from the base alongside sector/series/code for the same reason — render/serialize/`==` all guard on `base.nil?`, so the copy is neutral there and only the MR slug sees it. `spec/pubid/itu/distinctness_spec.rb` is the forcing function: it asserts all four surfaces differ for every marker pair. **Two more review findings worth keeping:** `technical_marker` is bound to the **`Cor.` branch alone**, not the head of `supplement_type` — offered before any token it was accepted on `Technical Err. 1`/`Technical Amd. 1` and then silently dropped by the builder's Corrigendum-only guard, collapsing those onto a *different* document (they are now cleanly rejected); and `series_code_body` carries a `(str("OB") >> dash).absent?` guard, because `ITU-T OB-1` otherwise reached the Recommendation fallback whose `validate_ob_no_sector!` raises an `ArgumentError` that escapes `Identifier.parse`'s `Parslet::ParseFailed` rescue — turning a rejected input into a crash for callers. `Code#to_s` renders glued suffixes before spaced ones, mirroring the grammar (a fixed edition-word-first order printed `Q.11a bis` back as `Q.11 bisa`). **Two known pre-existing gaps, deliberately not fixed and both pinned by specs in `distinctness_spec.rb`:** (a) the ITU URN convention encodes no supplement *type*, so `Amd. 1`/`Cor. 1`/`Err. 1`/`Add. 1` of one base share a URN and MR slug; (b) `build_supplement` copies sector/series/code down from the base but they are deliberately not serialized, so a supplement rebuilt through `from_hash` has none of them and its **MR slug collapses to `itu.<date>`** while every other surface stays symmetric. Both are true on `main` for `Amd.`/`Cor.`/`Err.` before this change — the new types simply inherit them, and `to_s`/`to_hash`/`==` distinguish everything correctly, which is what relaton's gate uses. Both would be fixed by giving `Supplement` an `mr_supplement_suffix` so the shared MR renderer recurses into `base` (as `AnnexOfRecommendation` already does), which changes every existing ITU supplement MR string — a deliberate call, not a tag-along. Also fixed here: `render_base` gained an `elsif series` branch, so a code-less identifier no longer renders a dangling trailing dot. Locked by `spec/pubid/itu/{code_suffixes,combined_suffixes,series_group,tail_forms}_spec.rb`, `spec/pubid/itu/identifiers/{addendum,appendix_of_recommendation,supplement_spelling,technical_corrigendum}_spec.rb`, and 7 new `spec/fixtures/itu/identifiers/pass/*.txt` files drawn from the real corpus. **Still out of scope (both declared not-ours by the hand-off):** ~47 malformed ITU-R docids left by a decommissioned crawler (`ITU-R BO`, `ITU-R M.5-BL-13` — series with no number; dataset bugs, not identifiers), and the 4 space-for-dot `ITU-T G 231` spellings relaton normalises on its side. (hand-off: itu-t-unparseable-forms.)
+
+- **ITU-R Reports (`Identifiers::Report`) and the class-strict `Identifier#==`**: ITU-R **Reports** are a publication series that numbers **independently** of Recommendations, so `ITU-R BT.2020-1` names *two* real, both-current documents (Report BT.2020-1, objective quality assessment, 2000; Recommendation BT.2020-1, UHDTV parameter values, 06/2014). 984 of 1,001 report records in `relaton-data-itu` were indexed as `pubid:itu:recommendation`, and 52 editions across 30 numbers (BT.2020, M.2083, M.2134 …) collided outright — the dataset keys files by identifier, so whichever was crawled last silently overwrote the other. ITU disambiguates with the leading word, so the identifier must too. **The leaf** `Identifiers::Report` (`_type: pubid:itu:report`) is shaped exactly like `Recommendation` — same attributes, same `StandardSerialization` flat block, so only `_type` distinguishes the two hashes — and adds just `render_base` (`"Report #{super}"`) and `mr_type` (`[super, "report"].join(".")` → `itu.r.report.bt-2020-1`). **Grammar**: a captured `report_word` marker (unlike `itu_prefix`'s decorative, *uncaptured* `"Recommendation "` literal, which stays as it is) plus a single `report_body` whose `(series >> dot).maybe` covers the with- and without-series shapes at once; `base_report` accepts **both** spellings (`Report ITU-R BT.2020-1` and the downstream `ITU-R Report BT.2020-1`), and `to_s` renders ITU's own leading form for either — so the infix spelling lives in `report_spec.rb` with an explicit expectation, **not** in the byte-exact pass fixtures. Two deliberate exclusions from `report_body`: **no `combined_suffixes`** (a joint `Report X/Y` would reach `Builder#build`'s `combined` branch, build a `CombinedIdentifier` and *silently drop the marker* — a clean parse failure is better), and a **`(str("OB") >> dot).absent?` guard** (an Operational Bulletin is cross-bureau; without it `Report ITU-T OB.1` routes to `SpecialPublication`, marker dropped, or trips `validate_ob_no_sector!`, whose `ArgumentError` escapes `Identifier.parse`'s `Parslet::ParseFailed` rescue). `base_report` is **first** in `rule(:base)` — which is what lets a supplement/annex/appendix *wrap* a Report — and order-free there because `itu_prefix` admits only `Recommendation `/`ITU` and `letter` is `[A-Z]`, so neither `series` nor `series_code_body` can consume `Report`; `report_identifier` sits in `rule(:identifier)` **after** supplement/annex/appendix (which match the longer wrapped form) and **before** `with_series`/`without_series` (which would match the infix spelling's `ITU-R` prefix and then fail on the unconsumed tail). The builder picks the class from `data[:report_marker]` in the existing Recommendation fallthrough; `build_supplement`/`build_annex_of_recommendation` need **no** change, since they recurse via `build(data[:base])`. **`Pubid::Itu::Identifier#==` is now class-strict** (`other.instance_of?(self.class)`, the rule `Supplement#==` already used) — the ITU *type* is part of the identity, not just sector/series/number. `self.class` rather than a hard-coded class keeps it **symmetric in both directions** (an `is_a?` guard would have made a Recommendation equal a Report one-way, and `#matches?` — which is `exclude(*ignore) == other.exclude(*ignore)` — resolve one to the other). Strictly stricter, so it can only turn `true` into `false`; it also closes the pre-existing one-way holes against `CombinedIdentifier` and `SpecialPublication`. **Consequences of the shared guard, both pinned by `spec/pubid/itu/type_strict_equality_spec.rb`:** comparisons that used to be *asymmetric* are now consistently false — most notably a bare primary designation vs its joint recommendation (`ITU-T G.780` vs `ITU-T G.780/Y.1351`, which was `true` one way and `false` the other on `main`, so no caller could rely on it either way). A caller matching a bare primary against a joint document must narrow on `root.number` (which still agrees) rather than on `==`. Per the cross-cutting ITU lesson, the marker reaches **all** identity surfaces: `to_s`, `generate_base_urn` (a `report` segment right after the sector — `urn:itu:r:report:BT.2020-1:2000`, which `UrnParser` also reads back), and the MR slug — including **`Supplement#mr_type`**, which is load-bearing and easy to miss: a supplement has no `mr_supplement_suffix`, so the shared MR renderer slugs it **flat** from the sector/series/code `build_supplement` copied up from its base and *never consults the base's class*, which made `Report ITU-R BT.2020-1 Suppl. 1` and `ITU-R BT.2020-1 Suppl. 1` share one slug (i.e. one output filename — the very overwrite this type prevents). It appends `report` when **`root`** is a Report, so a supplement of an *annex* of a Report is covered too. **`PREFIXES` stays `["ITU"]`** — the leading `Report` token is deliberately not registered for prefix routing (a generic English word; the mixin's ambiguous-token exclusion), and the infix spelling routes on `ITU` as before. **Backwards compatibility is exact**: a bare `ITU-R BT.2020-1` still builds a `Recommendation` with an unchanged hash/`to_s`/URN — nothing in the grammar or the builder fires without the marker, so none of the 20,728 published index rows move. Locked by `spec/pubid/itu/identifiers/report_spec.rb`, a `distinctness_spec.rb` pair, rows in `root_number_spec.rb`/`serialization_spec.rb`/`urn_parser_spec.rb`, and `spec/fixtures/itu/identifiers/pass/report.txt`. **Out of scope (relaton's side, sequenced after this):** `DataParserR`/`DataCrawlerR` emitting the new docid form, `Relaton::Itu::Pubid`'s reference parser learning a `report` rule, and the `relaton-data-itu` filename-namespace migration + re-crawl that actually recovers the 34 missing Recommendations and 18 missing Reports. (hand-off: itu-r-report-identifier-type.)
+
+## From the root note "Parse-failure error contract — uniform across every flavor"
+
+**ITU's length guard was an early `return`, not a raise, and its comment blamed the wrong caller.** `Identifier.normalize_whitespace` (`lib/pubid/itu/identifiers/base.rb`) carried
+
+```ruby
+return identifier if identifier.length > ::Pubid::MAX_INPUT_LENGTH
+```
+
+under a note claiming "`Pubid.parse` rejects it before this point". That was wrong twice: `Pubid.parse` never routes a human-readable string to a flavor at all (`lib/pubid.rb` raises `ArgumentError: No flavor specified` for anything that is not an MR string or a URN), and ITU had no raising guard of its own — so an over-long string reached the ITU parser through both `Pubid::Itu.parse` and `Pubid::Itu::Identifier.parse`. The guard now lives in `self.parse` as the standard inline pair, and the comment says what actually protects the method.
+
+**ITU was also the delegate in the most-visible class leak.** `Pubid::Iso.parse("ITU-T G.711")` detects an MR-shaped string, routes through `Pubid::Parsers::MrString`, and lands in `Pubid::Itu::Identifier.parse` — which raised `RuntimeError`. So `Pubid::Iso.parse` raised **two different classes** depending on its input, and a relaton-cli caller rescuing `Parslet::ParseFailed` got a raw backtrace for the ITU-shaped half. Converting ITU fixed the ISO symptom; `spec/pubid/parse_error_spec.rb` pins that exact route by name, because a generic junk string never reaches it.
+
+- **The five supplement types rendered plain under `to_s(annotated: true)`.**
+  `Pubid::Itu::Identifier#to_s` annotates, but `Addendum`, `Amendment`,
+  `Corrigendum`, `Errata` and `Supplement` each override it and none calls
+  `super` — they all funnel through `Supplement#render_supplement(label)`.
+  The wrap cannot live in that helper, which takes a label and no options,
+  so each of the five `to_s` is a one-line
+  `annotate_plain_render(render_supplement("…"), **opts)`.
+
+  `render_supplement` starts from `base.to_s` with no options, so the base
+  arrives plain and the single outer annotation covers the whole string —
+  the base's own tokens are reached by `Annotator#emit_tokens` walking
+  `base`.
+
+## Contribution (Temporary Document) — pubid#340
+
+`Pubid::Itu::Identifiers::Contribution` models the working documents a study
+group circulates, mirroring pubid-itu 1.15's `Identifier::Contribution`
+(`%{series}-C%{number}`): "ITU-R SG17-C1000", sector- and language-suffixed
+per the existing rules ("ITU-T SG17-C1000-E"). The grammar entry sits between
+`with_series` and `series_code_identifier` — the **-C marker (dash + "C" +
+digits) is the discriminator**: a series-code document's post-dash number
+starts with digits or is all letters, never "C"+digits, so the two dash
+shapes cannot shadow each other in either direction ("ITU-T EMC-5" still
+builds a Recommendation, locked by a spec). The builder branch carries the
+`:contribution_marker`; `root.number` reaches the C-number through the shared
+`code.number` reader, so relaton-index keys it normally.
+
+**`locate_type` was broken for every leaf, not just this one**: no ITU class
+ever defined a `type` hash, so `Pubid::Itu.locate_type` raised `NoMethodError`
+on any call. The base now derives the key from the class name
+(`Contribution` → `:contribution`, `AnnexOfRecommendation` →
+`:annex_of_recommendation`) — plain `gsub` camel→snake, because ActiveSupport's
+`underscore` is not a dependency. metanorma-itu constructs through this
+lookup; its flavor-local `pubid_contribution.rb` render override can be
+deleted once it migrates.

data/lib/pubid/itu/builder.rb

@@ -68,6 +68,16 @@ module Pubid
           return build_question(data)
         end
 
+        # Contribution (Temporary Document) — "ITU-R SG17-C1000" (pubid#340).
+        if data[:contribution_marker]
+          return Identifiers::Contribution.new(
+            sector: Components::Sector.new(sector: data[:sector].to_s),
+            series: Components::Series.new(series: data[:series].to_s),
+            code: build_code(data),
+            language: data[:language]&.to_s,
+          )
+        end
+
         # Build basic recommendation or combined identifier
         sector = Components::Sector.new(sector: data[:sector].to_s)
         series = Components::Series.new(series: data[:series].to_s) if data[:series]
@@ -358,3 +368,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Itu::Builder.prepend(Pubid::Builder::AllPartsWrap)

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

@@ -20,6 +20,8 @@ module Pubid
       # +subseries+ (dot-separated, flavor-specific) and +parts+
       # (dash-separated).
       class Code < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :imp_marker, :string
         attribute :number, :string
         attribute :series_suffix, :string

data/lib/pubid/itu/components/designation.rb

@@ -13,6 +13,8 @@ module Pubid
       #
       # Format: SERIES.CODE  (e.g. "Y.1351", "Y.1362-2")
       class Designation < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :series, Pubid::Itu::Components::Series
         attribute :code, Pubid::Itu::Components::Code
 

data/lib/pubid/itu/components/sector.rb

@@ -8,6 +8,8 @@ module Pubid
       # ITU Sector component
       # Values: R (Radio), T (Telecommunications), D (Development)
       class Sector < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :sector, :string # R, T, or D
 
         VALID_SECTORS = %w[R T D].freeze

data/lib/pubid/itu/components/series.rb

@@ -8,6 +8,8 @@ module Pubid
       # ITU Series component
       # Examples: BO, V, X, A, etc.
       class Series < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :series, :string # e.g., BO, V, X, R, SG1, OB
 
         def to_s

data/lib/pubid/itu/identifiers/base.rb

@@ -37,6 +37,16 @@ module Pubid
       end
       private_class_method :normalize_whitespace
 
+      # The type key used by Pubid::Itu.locate_type — the class name
+      # ("Contribution" => :contribution). No ITU leaf ever defined a
+      # `type` hash, so locate_type raised NoMethodError on every call;
+      # the derived default gives every concrete leaf a key for free
+      # (pubid#340's ask). metanorma-itu constructs via this lookup.
+      def self.type
+        leaf = name.split("::").last
+        { key: leaf.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym }
+      end
+
       # Long-form ↔ ITU single-letter language code map. The parser produces
       # single-letter codes (E/F/S/R/A/C); API callers (e.g. metanorma-itu)
       # pass long-form (en/fr/es/ru/ar/zh). Storage is normalized to the

data/lib/pubid/itu/identifiers/contribution.rb

@@ -0,0 +1,31 @@
+# frozen_string: true
+
+module Pubid
+  module Itu
+    module Identifiers
+      # ITU Contribution (Temporary Document) — the working documents a study
+      # group circulates, numbered per study group.
+      #
+      # Format: ITU-{SECTOR} {SERIES}-C{NUMBER}    e.g. ITU-R SG17-C1000
+      #
+      # Mirrors pubid-itu 1.15's Pubid::Itu::Identifier::Contribution
+      # ("%{series}-C%{number}"), which metanorma-itu builds from
+      # `:doctype: contribution` documents (pubid#340).
+      class Contribution < Identifier
+        include StandardSerialization
+
+        def render_base(**_opts)
+          "#{publisher}-#{sector} #{series}-C#{code&.number}"
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Contribution)
+
+          sector == other.sector &&
+            series == other.series &&
+            code == other.code
+        end
+      end
+    end
+  end
+end

data/lib/pubid/itu/identifiers/supplement.rb

@@ -131,6 +131,21 @@ module Pubid
         # Builder#build_supplement) and are deliberately not serialized (see
         # supplement_sector_to_kv), so comparing them would make a parsed
         # identifier unequal to the same identifier rebuilt via from_hash.
+        # A subset match follows the same rules as `==` below: the two
+        # rendering flags are not identity, and when a base is present the
+        # sector/series/code copies of the base are not serialized.
+        SUBSET_BASE_COPIES = %i[sector series code series_word].freeze
+
+        def self.subset_ignored_attributes
+          %i[number_glued slash_joined]
+        end
+
+        def subset_attribute_match?(name, mine, theirs)
+          return true if base && SUBSET_BASE_COPIES.include?(name)
+
+          super
+        end
+
         def ==(other)
           return false unless other.instance_of?(self.class)
 

data/lib/pubid/itu/identifiers.rb

@@ -11,6 +11,7 @@ module Pubid
       autoload :AppendixOfRecommendation,
                "#{__dir__}/identifiers/appendix_of_recommendation"
       autoload :CombinedIdentifier, "#{__dir__}/identifiers/combined_identifier"
+      autoload :Contribution, "#{__dir__}/identifiers/contribution"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :Errata, "#{__dir__}/identifiers/errata"
       autoload :Handbook, "#{__dir__}/identifiers/handbook"

data/lib/pubid/itu/parser.rb

@@ -323,6 +323,22 @@ module Pubid
           (digits | letter.repeat(1)).as(:number) >> parts
       end
 
+      # ITU Contribution (Temporary Document) — "ITU-R SG17-C1000" (pubid#340).
+      # The "-C" marker before the number distinguishes it from every
+      # neighbouring shape: a series-code document's post-dash number starts
+      # with digits or is all letters (never "C"+digits), and with_series
+      # requires a dot after the series.
+      rule(:contribution) do
+        itu_prefix >>
+          sector >>
+          space >>
+          series >>
+          str("-C").as(:contribution_marker) >>
+          number >>
+          parts >>
+          language.maybe
+      end
+
       rule(:base_series_code) do
         itu_prefix >>
           sector >>
@@ -656,9 +672,10 @@ module Pubid
           numeric_question |
           letter_question |
           with_series |
+          contribution |
           # Unreachable earlier: special_publication needs the literal "OB",
-          # handbook/numeric_question need leading digits, and letter_question
-          # needs series >> dot. Before without_series, whose code needs digits.
+          # handbook/numeric_question need leading digits, letter_question
+          # needs series >> dot, and contribution needs "-C" after the series.
           series_code_identifier |
           without_series
       end

data/lib/pubid/jcgm/CLAUDE.md

@@ -0,0 +1,7 @@
+# JCGM flavor notes
+
+JCGM meetings and URN parsing.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/jcgm/` or `spec/pubid/jcgm/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **JCGM meeting year is optional (`JCGM 11st Meeting`)**: a meeting's trailing ` (YYYY)` group is a *separable* component, not part of its identity — JCGM numbers its meetings in one sequence, so the ordinal alone names the event. `rule(:meeting_identifier)` wraps the **whole** group in `.maybe` (not the year inside it, so a dangling `(`, an empty `()` or a truncated `(200)` still fails), mirroring `date_portion.maybe` in `rule(:base)`; `render_meeting` appends the group only when `date` is present. No builder or serialization change was needed: `Builder::Base#assign_attributes` iterates the parsed hash, so an absent `:date` key is simply never assigned, and `SingleIdentifier#emit_kv` already drops a nil value — a dateless meeting is `{_type, number}` and a dated one is byte-identical to before, so **no index migration follows**. **The load-bearing third surface is `UrnParser#parse_meeting_urn`**: `UrnGenerator#generate_meeting_urn` had *always* guarded the date and emitted the short `urn:jcgm:meeting:11`, but the parser rebuilt the ungrammatical `"JCGM 11st Meeting ()"` from it — so the dateless form must be made optional on the URN read-back too, or the round-trip the relaton index depends on breaks. **The whole `UrnParser` was converted to build identifiers directly from the URN segments** (the BIPM pattern; 5 of 38 flavors construct directly, the rest use the shared `flavor_parse` helper, which stays for them). Rendering a string and re-parsing it flattens the segments and silently loses whatever the string form cannot carry, which is what three **pre-existing** defects were: `urn:jcgm:gum.6:2020` **raised** (`"JCGM gum.6:2020"` is not a grammar form); the language segment was dropped (`urn:jcgm:100:2008:en` → `JCGM 100:2008`); and `number, year = parts` discarded every segment past the second, so a supplement decayed into **the standard it amends** — `urn:jcgm:200:2008:corrigendum` → `JCGM 200:2008`, a different document, with no error. The supplement marker (`corrigendum`/`amendment`, written by the generator as the `type_code`) splits the segments: everything before it is the base document, everything after is the supplement's own number and date. Four things the string round-trip used to supply for free are now explicit, and each is load-bearing: (1) **`typed_stage` comes from `Jcgm.locate_stage`, the same registry lookup `Builder#locate_typed_stage` uses — NOT from the attribute default** — because `SingleIdentifier.published_typed_stage` additionally sets `original_abbr`, which would make a URN-reconstructed id **unequal** to a parsed one; the marker is mapped to the abbreviation the registry indexes (`amendment` → `Amd`, since `locate_stage` matches `abbr`, not `type_code`), and the class then comes from `Jcgm.locate_type(typed_stage.type_code)` so one lookup fixes both. **Guide and GumGuide deliberately take the default instead**, because the grammar emits no type token for them and `Builder#build` fills theirs from `published_typed_stage` too — matching the builder means matching *which* of the two paths it took. (2) The meeting number is normalized with **`to_i`**, matching `Identifiers::Meeting.ordinal`, so `011` still reads back as `11` and a missing or non-numeric segment as `0`. (3) The year is **validated against the grammar's `19xx|20xx`** and rejected with `Pubid::UrnParser::Errors::ParseError` (the easc/gost convention) — with no re-parse, nothing else would catch a malformed segment. (4) A language code is mapped back through the inverse of `Builder::Base::LANG_CHAR_MAP` to restore `original_code`, which is what the renderer prints (`en,fr` → `(E/F)`). **KNOWN GAP, generator-side and deliberately unchanged**: a full date renders as its year alone (`JCGM GUM-1:2022-11-28` → `urn:jcgm:gum.1:2022`), so a URN cannot restore month and day; widening it would change already-published URNs. 30 of the 32 corpus ids now round-trip through the URN byte-exactly, and those 2 are the truncated-date pair. (That `original_abbr` asymmetry is **since fixed** — see `lib/pubid/iec/CLAUDE.md` — so the default now agrees too and the lookup mirrors the builder for clarity rather than necessity.) **Deliberately not a typed error**: the earlier reading of this defect was to raise on a nil date; an undated meeting reference is unambiguous and legitimate, and raising would leave relaton's `Bib::ItemData#to_most_recent_reference` with nothing to return. **Do not add the English teens exception to `Identifiers::Meeting.ordinal`** — the real records print `11st`/`12nd`/`13rd`, and three published documents round-trip through that naive rule. Locked by `spec/pubid/jcgm/meeting_partial_spec.rb` plus a bare-form row in `urn_parser_spec.rb`. **Still open, separate call**: `Meeting.new(number: "11").to_s` raises `NoMethodError` (`number` is a `Components::Code`; a bare String is accepted at construction and only explodes at render), and `Meeting#ordinal` renders `"0th"` for a nil `number`. (hand-off: jcgm-meeting-render-nil-date.)

data/lib/pubid/jcgm/builder.rb

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

data/lib/pubid/jcgm/components/publisher.rb

@@ -6,6 +6,8 @@ module Pubid
   module Jcgm
     module Components
       class Publisher < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :publisher, :string
 
         def to_s

data/lib/pubid/jis/builder.rb

@@ -20,6 +20,9 @@ module Pubid
                        build_single_identifier(data)
                      end
         attach_symbol(identifier, data)
+        # "(all parts)" names every part of the document, so it wraps the
+        # document, which holds no mark itself.
+        data[:all_parts] ? identifier.to_all_parts : identifier
       end
 
       private
@@ -37,7 +40,6 @@ module Pubid
           parts: extract_part_strings(data[:parts]),
           year: data[:year]&.to_i,
           language: data[:language]&.to_s,
-          all_parts: (true if data[:all_parts]),
           reaffirmed: (true if data[:reaffirmed]),
         }
 
@@ -114,3 +116,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Jis::Builder.prepend(Pubid::Builder::AllPartsWrap)