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

data/lib/pubid/iso/builder.rb

@@ -143,7 +143,7 @@ module Pubid
         return nil unless year_value.between?(1900, 2099)
 
         {
-          number: code_class.new(value: number),
+          number: number,
           date: ::Pubid::Components::Date.new(year: part),
         }
       end
@@ -197,7 +197,7 @@ module Pubid
           # or "105/F" ('F' is part)
           # or "5843/6" ('6' is part)
           # LEGACY: "4037-1979" (number-year, year should become date)
-          parse_number_with_part(value, code_class: Pubid::Iso::Components::Code)
+          parse_number_with_part(value)
 
         when :directives_type
           # nothing to do here, just return nil
@@ -240,8 +240,10 @@ module Pubid
           original_text = value.to_s
           # Extract just the digit(s) for the number field
           number_string = original_text.match(/\d+/)&.to_s
-          number_code = number_string ? Pubid::Iso::Components::Code.new(value: number_string) : nil
-          Pubid::Components::Edition.new(number: number_code,
+          # A plain string: Components::Edition#number is typed Value, so a
+          # component here would leak a live Ruby object into to_hash (and a
+          # !ruby/object tag into to_yaml).
+          Pubid::Components::Edition.new(number: number_string,
                                          original_text: original_text)
 
         when :languages
@@ -260,8 +262,7 @@ module Pubid
 
         when :subgroup
           # Handle JTC 1 subgroup in directives (ISO/IEC JTC 1 DIR)
-          # Store as a component for potential use in rendering
-          Pubid::Iso::Components::Code.new(value: value.to_s)
+          value.to_s
 
         when :supplements
           # Handle bundled supplements (+ operator)
@@ -274,12 +275,10 @@ module Pubid
 
         # TC Document attributes
         when :tc_type, :sc_type, :wg_type
-          # TC, SC, WG types are code components
-          Pubid::Iso::Components::Code.new(value: value.to_s)
+          value.to_s
 
         when :tc_number, :sc_number, :wg_number
-          # TC, SC, WG numbers are code components
-          Pubid::Iso::Components::Code.new(value: value.to_s)
+          value.to_s
 
         when :year
           # For TC documents with year, convert to Date
@@ -290,7 +289,7 @@ module Pubid
           # For regular identifiers, this is handled in :number_with_part
           if value.is_a?(Parslet::Slice) || value.is_a?(String) ||
               value.is_a?(Integer)
-            Pubid::Iso::Components::Code.new(value: value.to_s)
+            value.to_s
           else
             value
           end

data/lib/pubid/iso/bundled_identifier.rb

@@ -86,15 +86,17 @@ module Pubid
         base_document&.copublishers
       end
 
+      # See the note on Pubid::BundledIdentifier#to_s: `**opts` carries flags
+      # this list does not name, `annotated:` above all.
       def to_s(lang: :en, lang_single: false, with_edition: false, format: nil,
-stage_format_long: nil, with_date: nil)
+stage_format_long: nil, with_date: nil, **opts)
         parts = [base_document.to_s(lang: lang, lang_single: lang_single,
-                                    with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)]
+                                    with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)]
 
         # Add each supplement with "+" separator
         supplements.each do |supplement|
           supplement_str = supplement.to_supplement_s(lang: lang, lang_single: lang_single,
-                                                      with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)
+                                                      with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)
           parts << "+ #{supplement_str}"
         end
 

data/lib/pubid/iso/combined_identifier.rb

@@ -9,11 +9,13 @@ module Pubid
                 polymorphic: true, collection: true
       attribute :type, :string, default: -> { "combined_identifier" }
 
-      def to_s(lang: :en, lang_single: false)
+      # `**opts` carries render flags this list does not name (`annotated:`),
+      # which the closed signature used to reject outright.
+      def to_s(lang: :en, lang_single: false, **opts)
         [
-          base.to_s(lang: lang, lang_single: lang_single),
+          base.to_s(lang: lang, lang_single: lang_single, **opts),
           additional_identifiers.map do |id|
-            id.to_s(lang: lang, lang_single: lang_single)
+            id.to_s(lang: lang, lang_single: lang_single, **opts)
           end,
         ].flatten.join(" | ")
       end

data/lib/pubid/iso/components.rb

@@ -3,7 +3,6 @@
 module Pubid
   module Iso
     module Components
-      autoload :Code, "#{__dir__}/components/code"
       autoload :Publisher, "#{__dir__}/components/publisher"
     end
   end

data/lib/pubid/iso/identifier.rb

@@ -56,9 +56,14 @@ module Pubid
         ts ? dup.tap { |id| id.typed_stage = ts } : dup
       end
 
-      attribute :number, ::Pubid::Iso::Components::Code
-      attribute :part, ::Pubid::Iso::Components::Code
-      attribute :subpart, ::Pubid::Iso::Components::Code
+      # Plain strings. Iso::Components::Code existed to join `parts` with
+      # "-", a composition no ISO identifier ever reached: `parts` is never
+      # written in lib/pubid/iso and no Code in the 7,613-id corpus carries
+      # anything but `value`. ISO part and subpart are sibling attributes, not
+      # fields of the number.
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
 
       # Polymorphic type map for lutaml::Model key_value serialization
       # Maps polymorphic_name → class name for deserialization
@@ -166,9 +171,14 @@ module Pubid
       def stage_from_kv(model, value)
         return if value.nil? || value.to_s.empty?
 
+        # The fallback consults the flavor-wide table. It used to call
+        # `Pubid::Iso::Scheme`, a class removed repo-wide in e3c19ea1 — so any
+        # code absent from the class's own TYPED_STAGES raised NameError
+        # instead of falling back. The IEC twin (iec/identifier.rb) was
+        # migrated at the time; ISO was missed.
         ts = (model.class.const_defined?(:TYPED_STAGES) &&
               model.class::TYPED_STAGES.find { |t| t.code.to_s == value.to_s }) ||
-             Pubid::Iso::Scheme.locate_typed_stage_by_code(value)
+             Pubid::Iso.locate_stage_by_code(value)
         return unless ts
 
         # The renderer prefers `original_abbr` (the parsed surface form); without
@@ -208,8 +218,10 @@ module Pubid
         doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, v.to_s))
       end
 
+      # number/part/subpart are plain strings; the converter name is kept
+      # so the key_value map below does not have to change.
       def build_code(value)
-        ::Pubid::Iso::Components::Code.new(value: value.to_s)
+        value.to_s
       end
 
       # --- date serialized flat as year/month/day ---
@@ -283,8 +295,13 @@ module Pubid
       end
 
       def self.parse(string, format: :auto)
+        unless string.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
         if string.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         format = Pubid::FormatDetector.detect(string) if format == :auto
@@ -296,11 +313,6 @@ module Pubid
           Pubid::Parsers::MrString.parse(string)
         else
           parsed = Pubid::Iso::Parser.new.parse(string)
-          if parsed.nil? || parsed.empty?
-            raise Pubid::Iso::Parser::ParseError,
-                  "Invalid identifier format"
-          end
-
           Pubid::Iso::Builder.new.build(parsed)
         end
       end

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

@@ -4,7 +4,10 @@ module Pubid
   module Iso
     module Identifiers
       class Directives < SingleIdentifier
-        attribute :subgroup, ::Pubid::Components::Code
+        # A plain string ("JTC 1"). The serialized form flattens from
+        # `{"value" => "JTC 1"}` to `"JTC 1"`, so the 5 directives rows of
+        # relaton-data-iso need a re-crawl; no compatibility shim is kept.
+        attribute :subgroup, :string
 
         # Merges with Identifier's block (base attributes); only adds the
         # Directives-specific subgroup so it survives to_hash/from_hash.
@@ -46,15 +49,15 @@ module Pubid
           parts << ([publisher] + copubs).map(&:body).map(&:downcase).join("-")
 
           if subgroup
-            subgroup_parts = subgroup.value.split
+            subgroup_parts = subgroup.split
             parts << subgroup_parts[0].downcase if subgroup_parts[0]
             parts << subgroup_parts[1] if subgroup_parts[1]
           end
 
           parts << "dir"
 
-          parts << number.value if number
-          parts << part.value.downcase if part
+          parts << number.to_s if number
+          parts << part.to_s.downcase if part
           parts << date.year if date
 
           parts.join(":")

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

@@ -68,12 +68,12 @@ module Pubid
         # end
 
         def to_s(lang: :en, lang_single: false, with_edition: false,
-format: nil, stage_format_long: nil, with_date: nil)
+format: nil, stage_format_long: nil, with_date: nil, **opts)
           if base
             # Full rendering with base identifier
             [
               base.to_s(lang: lang, lang_single: lang_single,
-                                   with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date),
+                                   with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts),
               " #{supplement_publisher.render}",
               " SUP", # Always render as "SUP" even though typed_stage.abbreviation is "DIR SUP"
               (date ? ":#{date.render}" : ""),
@@ -81,13 +81,13 @@ format: nil, stage_format_long: nil, with_date: nil)
             ].join
           else
             # Simplified rendering for bundled identifiers (just the supplement part)
-            to_supplement_s(lang: lang, lang_single: lang_single)
+            to_supplement_s(lang: lang, lang_single: lang_single, **opts)
           end
         end
 
         # Render just the supplement part (for use in bundled identifiers)
         def to_supplement_s(lang: :en, lang_single: false, with_edition: false,
-format: nil, stage_format_long: nil, with_date: nil)
+format: nil, stage_format_long: nil, with_date: nil, **_opts)
           date_str = if date
                        month_part = date.month ? "-#{date.month}" : ""
                        ":#{date.render}#{month_part}"

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/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/parser.rb

@@ -3,7 +3,7 @@ require "parslet"
 
 module Pubid
   module Iso
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 require "lutaml/model"
 
 module Pubid
@@ -31,8 +32,13 @@ module Pubid
     # @param format [Symbol] :auto, :human, :mr_string, or :urn
     # @return [Identifier] the parsed identifier
     def self.parse(identifier, format: :auto)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
       if identifier.length > Pubid::MAX_INPUT_LENGTH
-        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
       format = Pubid::FormatDetector.detect(identifier) if format == :auto
@@ -60,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]
@@ -100,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/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]

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

@@ -6,8 +6,8 @@ module Pubid
       # Addendum identifier (Add.)
       # Pattern: "ITU-T I.363 (1993) Add. 1 (11/1993)"
       class Addendum < Supplement
-        def to_s
-          render_supplement("Add.")
+        def to_s(**opts)
+          annotate_plain_render(render_supplement("Add."), **opts)
         end
       end
     end

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

@@ -10,8 +10,8 @@ module Pubid
         # supplement types (Cor./Err./Suppl./Add.). The parser accepts both
         # spellings (see Parser#supplement_type), so the period-less input form
         # still round-trips through parse — it just normalizes here.
-        def to_s
-          render_supplement("Amd.")
+        def to_s(**opts)
+          annotate_plain_render(render_supplement("Amd."), **opts)
         end
       end
     end

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

@@ -6,18 +6,29 @@ module Pubid
     class Identifier < ::Pubid::Identifier
       # Parse an ITU identifier string into an identifier object.
       def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         parsed = Parser.parse(normalize_whitespace(identifier))
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse ITU identifier '#{identifier}': #{e.message}"
       end
 
       # ITU's own listings occasionally carry a doubled space
       # ("ITU-T D.271  (10/2016)"). Whitespace is never significant in an ITU
       # identifier, so collapse runs of it rather than teaching every rule to
       # tolerate them. Any string over the shared input-length guard is left
-      # untouched — `Pubid.parse` rejects it before this point, and the guard
-      # exists precisely to keep long inputs away from regexes.
+      # untouched: `self.parse` above rejects it before this point, and the
+      # guard exists precisely to keep long inputs away from regexes. (This
+      # note used to credit `Pubid.parse` with the rejection, which was wrong
+      # in both directions — `Pubid.parse` never routes a human-readable ITU
+      # string to a flavor, and ITU carried no raising guard of its own until
+      # one was added to `self.parse`, so an over-long string did reach here.)
       def self.normalize_whitespace(identifier)
         return identifier unless identifier.is_a?(String)
         return identifier if identifier.length > ::Pubid::MAX_INPUT_LENGTH
@@ -26,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
@@ -184,10 +205,13 @@ module Pubid
       # @param format [Symbol] :long for title-style rendering of supported
       #   identifiers, otherwise the default short form.
       def to_s(**opts)
+        annotated = opts[:annotated]
         opts = self.class.normalize_to_s_opts(opts)
         result = render_base(**opts) + render_language_suffix
         result += " | #{common_text_twin}" if common_text_twin
-        result
+        # ITU composes its own string rather than going through `render`, so it
+        # never reaches the shared annotation hook. Apply it here.
+        annotate_plain_render(result, annotated: annotated)
       end
 
       def render_base(**_opts)

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/corrigendum.rb

@@ -19,8 +19,8 @@ module Pubid
           map "technical", to: :technical
         end
 
-        def to_s
-          render_supplement(technical ? "Technical Cor." : "Cor.")
+        def to_s(**opts)
+          annotate_plain_render(render_supplement(technical ? "Technical Cor." : "Cor."), **opts)
         end
 
         # `super` already enforces instance_of?(self.class), so this only has