pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.9

data/lib/pubid/gost.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gost
+    extend Pubid::PrefixesSupport
+
+    # Leading identifier tokens that a GOST document id can start with.
+    # Latin "GOST" and Cyrillic "ГОСТ" are both official; "R" (Russian
+    # national, e.g. "GOST R 34.12-2015") routes to this flavor too.
+    PREFIXES = ["GOST", "ГОСТ"].freeze
+
+    autoload :Builder,      "#{__dir__}/gost/builder"
+    autoload :Identifier,   "#{__dir__}/gost/identifier"
+    autoload :Identifiers,  "#{__dir__}/gost/identifiers"
+    autoload :Parser,       "#{__dir__}/gost/parser"
+    autoload :Renderer,     "#{__dir__}/gost/renderer"
+    autoload :UrnGenerator, "#{__dir__}/gost/urn_generator"
+    autoload :UrnParser,    "#{__dir__}/gost/urn_parser"
+
+    # Parse a GOST identifier string into an identifier object.
+    # @param identifier [String]
+    # @return [Pubid::Gost::Identifier]
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human.
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Gost::Renderer)
+
+    # Auto-discover identifier types from the Identifiers namespace.
+    # @return [Array<Class>]
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c < Pubid::Identifier }
+        .reject { |c| c == Identifier }
+    end
+
+    # Lookup: type key → identifier class
+    # @param code [String, Symbol]
+    # @return [Class, nil]
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+  end
+end
+
+Pubid::Registry.register(:gost, Pubid::Gost)

data/lib/pubid/iala/builder.rb

@@ -10,14 +10,15 @@ module Pubid
         return build_annex(hash) if hash[:annex_marker]
 
         type_letter = stringify(hash[:type_letter])&.upcase
+        klass = Iala.identifier_klass_for_type_letter(type_letter)
 
         attrs = {
-          number:   build_number(hash, type_letter),
+          number:   build_number(hash, klass),
           edition:  stringify(hash.dig(:edition, :edition_value)),
           language: stringify(hash.dig(:language_group, :language))&.upcase,
         }.compact
 
-        Iala.identifier_klass_for_type_letter(type_letter).new(**attrs)
+        klass.new(**attrs)
       end
 
       def self.build(parsed)
@@ -32,11 +33,11 @@ module Pubid
       def build_annex(hash)
         base_hash = hash[:base]
         base_type = stringify(base_hash[:type_letter])&.upcase
-        base_number = build_number(base_hash, base_type)
-        base = Iala.identifier_klass_for_type_letter(base_type).new(number: base_number)
+        base_klass = Iala.identifier_klass_for_type_letter(base_type)
+        base = base_klass.new(number: build_number(base_hash, base_klass))
 
         attrs = {
-          base_identifier: base,
+          base: base,
           annex_form:      stringify(hash[:annex_marker]),
           letter:          stringify(hash[:annex_letter]),
           edition:         stringify(hash.dig(:edition, :edition_value)),
@@ -49,43 +50,37 @@ module Pubid
       # Compose the full number string from the leading doc_number plus any
       # dotted continuation (GA01.13 → "01.13", L2.1.11 → "2.1.11") plus
       # the optional dash-separated subpart (C0103-1 → "0103-1", L2.7.1-2
-      # → "2.7.1-2"). Padding is type-aware per IALA's canonical form:
-      # typed S/R/G/M/C zero-pad to 4 digits; GeneralAssembly (GA) zero-
-      # pads each segment to 2; Advices (A) and Letters (L) preserve input
-      # (their canonical form is already what the IALA site prints).
-      def build_number(hash, type_letter = nil)
+      # → "2.7.1-2"). Padding is class-driven: the resolved identifier
+      # class declares its canonical IALA cover-page widths via
+      # `canonical_number_width` / `canonical_dotted_segment_width`, so a
+      # new type declares its padding on its own class instead of editing
+      # this builder's case statement.
+      def build_number(hash, klass)
         base = stringify(hash[:doc_number])
         return base unless base
 
-        base = canonical_base(base, type_letter)
+        base = canonical_base(base, klass)
 
         dots = hash[:doc_number_dots]
-        dots_str = dots.is_a?(Array) ? "" : canonical_dots(stringify(dots).to_s, type_letter)
+        dots_str = dots.is_a?(Array) ? "" : canonical_dots(stringify(dots).to_s, klass)
 
         subpart_str = hash[:subpart] ? "-#{subpart_to_s(hash[:subpart])}" : ""
         subpart_str = "" if subpart_str == "-"
         "#{base}#{dots_str}#{subpart_str}"
       end
 
-      # Per-type canonical width for the leading numeric run.
-      def canonical_base(base, type_letter)
-        case type_letter
-        when "S", "R", "G", "M", "C", "X", "P" then base.rjust(4, "0")
-        when "GA" then base.rjust(2, "0")
-        else base
-        end
+      def canonical_base(base, klass)
+        width = klass&.canonical_number_width
+        width ? base.rjust(width, "0") : base
       end
 
-      # Per-type canonical width for each dotted continuation segment.
-      # `str` looks like ".13" or ".1.11" (leading dot, then digits).
-      def canonical_dots(str, type_letter)
+      def canonical_dots(str, klass)
         return "" if str.empty?
 
-        if type_letter == "GA"
-          str.split(".", -1).map { |seg| seg.empty? ? seg : seg.rjust(2, "0") }.join(".")
-        else
-          str
-        end
+        width = klass&.canonical_dotted_segment_width
+        return str unless width
+
+        str.split(".", -1).map { |seg| seg.empty? ? seg : seg.rjust(width, "0") }.join(".")
       end
 
       # The subpart capture may be an array of {subpart_number: "1"},

data/lib/pubid/iala/identifier.rb

@@ -4,8 +4,7 @@ module Pubid
   module Iala
     # Base class for all IALA identifiers. Canonical name
     # Pubid::Iala::Identifier; every concrete IALA identifier
-    # (Identifiers::*) descends from it, and Identifiers::Base — aliased
-    # at the foot of identifiers/base.rb — points back to it.
+    # (Identifiers::*) descends from it.
     #
     # IALA identifiers have the form:
     #   [IALA ]{S|R|G|M|C|X|P}<4-digit number>[-<subpart>][ Ed <edition>][ (<LangLetter>)]
@@ -62,6 +61,32 @@ module Pubid
       def type_letter
         self.class.type[:short]
       end
+
+      class << self
+        # Zero-pad the leading numeric run of the document number to this
+        # width. nil means preserve the input verbatim. Subclasses declare
+        # their canonical IALA cover-page form via `number_width` (e.g.
+        # Standard declares 4 → M0001; GeneralAssembly declares 2 → GA01).
+        # The builder consults this instead of branching on type_letter.
+        attr_reader :canonical_number_width
+
+        # Zero-pad each dotted continuation segment of the number to this
+        # width. nil means preserve verbatim. Only GeneralAssembly (GA)
+        # sets this today — its series.index form (01.01, 01.13) is the
+        # canonical cover-page shape.
+        attr_reader :canonical_dotted_segment_width
+
+        # DSL: declare the canonical zero-pad width for the leading number.
+        private
+
+        def number_width(width)
+          @canonical_number_width = width
+        end
+
+        def dotted_segment_width(width)
+          @canonical_dotted_segment_width = width
+        end
+      end
     end
   end
 end

data/lib/pubid/iala/identifiers/advice.rb

@@ -5,7 +5,7 @@ module Pubid
     module Identifiers
       # IALA Advices (A prefix). Numbering is dashed: A12-01, A13-04.
       # Carries no edition in the corpus.
-      class Advice < Base
+      class Advice < Identifier
         def self.type
           { key: :advice, title: "Advice", short: "A" }
         end

data/lib/pubid/iala/identifiers/annex.rb

@@ -11,19 +11,19 @@ module Pubid
       #
       # The case of the marker is preserved (Annex vs ANNEX) for round-trip
       # fidelity. Edition and language apply to the Annex itself, not the base.
-      class Annex < Base
+      class Annex < Identifier
         # The publication this annex supplements. Always present; carries the
         # type letter and number (e.g. G1045).
-        attribute :base_identifier, ::Pubid::Iala::Identifier, polymorphic: true
+        attribute :base, ::Pubid::Iala::Identifier, polymorphic: true
         # "Annex" or "ANNEX" — preserved verbatim for exact round-trip.
         attribute :annex_form, :string
         # "A", "B", "C", "D", or nil for the bare form.
         attribute :letter, :string
 
         key_value do
-          map "base_identifier",
-              with: { to: :base_identifier_to_kv, 
-                      from: :base_identifier_from_kv }
+          map "base",
+              with: { to: :base_to_kv, 
+                      from: :base_from_kv }
           map "annex_form", to: :annex_form
           map "letter",     to: :letter
         end
@@ -36,20 +36,20 @@ module Pubid
         # methods via public_send during (de)serialization — a `private`
         # section here raises NoMethodError on to_hash (matches the public
         # visibility of Oiml::SupplementIdentifier's identical helpers).
-        def base_identifier_to_kv(model, doc)
-          base = model.base_identifier
+        def base_to_kv(model, doc)
+          base = model.base
           return unless base
 
           doc.add_child(
-            Lutaml::KeyValue::DataModel::Element.new("base_identifier",
+            Lutaml::KeyValue::DataModel::Element.new("base",
                                                      base.to_hash),
           )
         end
 
-        def base_identifier_from_kv(model, value)
+        def base_from_kv(model, value)
           return unless value
 
-          model.base_identifier = ::Pubid::Iala::Identifier.from_hash(value)
+          model.base = ::Pubid::Iala::Identifier.from_hash(value)
         end
       end
     end

data/lib/pubid/iala/identifiers/general_assembly.rb

@@ -5,9 +5,12 @@ module Pubid
     module Identifiers
       # IALA General Assembly resolutions (GA prefix). Numbering is dotted
       # with a series and an index: GA01.01, GA01.13. No edition.
-      class GeneralAssembly < Base
+      class GeneralAssembly < Identifier
+        number_width 2
+        dotted_segment_width 2
+
         def self.type
-          { key: :"general-assembly", title: "General Assembly Resolution", 
+          { key: :"general-assembly", title: "General Assembly Resolution",
             short: "GA" }
         end
       end

data/lib/pubid/iala/identifiers/guideline.rb

@@ -5,7 +5,9 @@ module Pubid
     module Identifiers
       # IALA Guidelines (G series).
       # Examples: G1015 Ed 2.2, G1078 Ed 2.1.
-      class Guideline < Base
+      class Guideline < Identifier
+        number_width 4
+
         def self.type
           { key: :guideline, title: "Guideline", short: "G" }
         end

data/lib/pubid/iala/identifiers/letter.rb

@@ -6,7 +6,7 @@ module Pubid
       # IALA Letters (L prefix). Numbering is dotted with a series, sub-series,
       # and item: L2.1.11, L2.7.1-2 (the trailing -2 is a sub-part on top of
       # the dotted number).
-      class Letter < Base
+      class Letter < Identifier
         def self.type
           { key: :letter, title: "Letter", short: "L" }
         end

data/lib/pubid/iala/identifiers/manual.rb

@@ -6,7 +6,9 @@ module Pubid
       # IALA Manuals (M prefix, planned).
       # Today manuals carry no code (NAVGUIDE, VTS Manual, …); M is
       # reserved for future numbered manuals.
-      class Manual < Base
+      class Manual < Identifier
+        number_width 4
+
         def self.type
           { key: :manual, title: "Manual", short: "M" }
         end

data/lib/pubid/iala/identifiers/model_course.rb

@@ -5,7 +5,9 @@ module Pubid
     module Identifiers
       # IALA Model Courses (C series).
       # Examples: C0103-1 Ed 3.0, C2001-1 Ed 1.0.
-      class ModelCourse < Base
+      class ModelCourse < Identifier
+        number_width 4
+
         def self.type
           { key: :"model-course", title: "Model Course", short: "C" }
         end

data/lib/pubid/iala/identifiers/recommendation.rb

@@ -5,7 +5,9 @@ module Pubid
     module Identifiers
       # IALA Recommendations (R series).
       # Examples: R0103 Ed 3.1, R0126 Ed 2.0, R1024 Ed 1.0.
-      class Recommendation < Base
+      class Recommendation < Identifier
+        number_width 4
+
         def self.type
           { key: :recommendation, title: "Recommendation", short: "R" }
         end

data/lib/pubid/iala/identifiers/report.rb

@@ -6,7 +6,7 @@ module Pubid
       # IALA Reports & Proceedings (X prefix, planned).
       # Today reports carry no code; X is reserved for future numbered
       # reports.
-      class Report < Base
+      class Report < Identifier
         def self.type
           { key: :report, title: "Report", short: "X" }
         end

data/lib/pubid/iala/identifiers/resolution.rb

@@ -6,7 +6,7 @@ module Pubid
       # IALA Resolutions and other Council publications (P prefix,
       # planned). Today resolutions carry no code; P is reserved for
       # future numbered resolutions.
-      class Resolution < Base
+      class Resolution < Identifier
         def self.type
           { key: :resolution, title: "Resolution", short: "P" }
         end

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

@@ -5,7 +5,9 @@ module Pubid
     module Identifiers
       # IALA Standards (S series).
       # Examples: S1010, S1020 Ed 2.0, S1070 Ed 2.0.
-      class Standard < Base
+      class Standard < Identifier
+        number_width 4
+
         def self.type
           { key: :standard, title: "Standard", short: "S" }
         end

data/lib/pubid/iala/identifiers.rb

@@ -3,7 +3,6 @@
 module Pubid
   module Iala
     module Identifiers
-      autoload :Base,             "#{__dir__}/identifiers/base"
       autoload :Advice,           "#{__dir__}/identifiers/advice"
       autoload :Annex,            "#{__dir__}/identifiers/annex"
       autoload :Standard,         "#{__dir__}/identifiers/standard"

data/lib/pubid/iala/renderer.rb

@@ -24,7 +24,7 @@ module Pubid
       # the marker form is preserved verbatim ("Annex" vs "ANNEX"), then the
       # optional letter, edition, and language.
       def render_annex(id)
-        base_str = id.base_identifier.to_s
+        base_str = id.base.to_s
         rendered = "#{base_str} #{id.annex_form}"
         rendered << " #{id.letter}" if id.letter
         rendered << " Ed #{id.edition}" if id.edition

data/lib/pubid/iala/urn_generator.rb

@@ -31,7 +31,7 @@ module Pubid
       #   G1045 Annex Ed 1           → urn:mrn:iala:pub:g1045:annex:ed1
       #   G1128 ANNEX A Ed 1.6 (E)    → urn:mrn:iala:pub:g1128:annex-a:ed1.6:e
       def generate_annex
-        base = identifier.base_identifier
+        base = identifier.base
         parts = ["urn:mrn:iala:pub",
                  "#{base.type_letter.downcase}#{base.number}"]
         annex_seg = identifier.letter ? "annex-#{identifier.letter.downcase}" : "annex"

data/lib/pubid/iala/urn_parser.rb

@@ -6,11 +6,15 @@ module Pubid
     #
     # UrnGenerator emits:
     #   urn:mrn:iala:pub:<type-lower><number>[:ed<edition>][:<lang-lower>]
+    # and for Annex identifiers:
+    #   urn:mrn:iala:pub:<base-code>:annex[-<letter>][:ed<edition>][:<lang>]
     #
     # Examples:
     #   urn:mrn:iala:pub:s1070:ed2.0          → IALA S1070 Ed 2.0
     #   urn:mrn:iala:pub:r1016:ed2.0:f        → IALA R1016 Ed 2.0 (F)
     #   urn:mrn:iala:pub:c0103-1              → IALA C0103-1
+    #   urn:mrn:iala:pub:g1045:annex:ed1      → IALA G1045 Annex Ed 1
+    #   urn:mrn:iala:pub:g1128:annex-a:ed1.6  → IALA G1128 ANNEX A Ed 1.6
     class UrnParser < Pubid::UrnParser::Base
       PREFIX = "urn:mrn:iala:pub:".freeze
 
@@ -21,15 +25,28 @@ module Pubid
 
         edition = nil
         language = nil
+        annex_form = nil
+        annex_letter = nil
+
         parts.drop(1).each do |seg|
-          if seg.start_with?("ed")
+          case seg
+          when /\Aannex(-([a-z]))?\z/i
+            # UrnGenerator emits "annex" (bare) for the Annex-without-letter
+            # form and "annex-X" (lettered) for the uppercase ANNEX form.
+            # The human parser accepts both "Annex" and "ANNEX"; mirror the
+            # generator's casing so URN round-trip is exact.
+            annex_letter = Regexp.last_match(2)&.upcase
+            annex_form = annex_letter ? "ANNEX" : "Annex"
+          when /\Aed/
             edition = seg.sub(/\Aed/, "")
-          elsif seg.length == 1 && seg.match?(/\A[a-z]\z/i)
+          when /\A[a-z]\z/i
             language = seg.upcase
           end
         end
 
         text = "IALA #{code.upcase}"
+        text += " #{annex_form}" if annex_form
+        text += " #{annex_letter}" if annex_letter
         text += " Ed #{edition}" if edition
         text += " (#{language})" if language
         flavor_parse(text)

data/lib/pubid/iala.rb

@@ -23,8 +23,8 @@ module Pubid
     end
 
     # Per-flavor format registry: inherits global formats, overrides :human
-    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifiers::Base.format_registry.register(:human, renderer: Iala::Renderer)
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Iala::Renderer)
 
     # Auto-discover all identifier types from the Identifiers namespace.
     # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
@@ -32,7 +32,7 @@ module Pubid
       @identifier_types ||= Identifiers.constants
         .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
         .select { |c| c.is_a?(Class) && c < Pubid::Identifier }
-        .reject { |c| c == Identifiers::Base }
+        .reject { |c| c == Identifier }
     end
 
     # Build typed stage index from identifier types
@@ -60,7 +60,7 @@ module Pubid
 
     # Look up an identifier class by its IALA type letter (S, R, G, M, C, X, P).
     # @param letter [String]
-    # @return [Class<Identifiers::Base>]
+    # @return [Class<Identifier>]
     def self.identifier_klass_for_type_letter(letter)
       @by_letter ||= identifier_types.to_h { |klass| [klass.type[:short], klass] }
       @by_letter.fetch(letter.to_s.upcase)

data/lib/pubid/iana/builder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    # Builds an IANA identifier object from a parse tree. There is a single
+    # concrete type (Registry), so the builder just extracts the slug fields.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        Identifiers::Registry.new(
+          registry: data[:registry].to_s,
+          sub_registry: data[:sub_registry]&.to_s,
+        )
+      end
+    end
+  end
+end

data/lib/pubid/iana/identifier.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    # Base class for every IANA identifier AND the flavor's parse/create entry
+    # point. Concrete identifiers under Pubid::Iana::Identifiers descend from
+    # this class, so a parsed IANA id is an instance of Pubid::Iana::Identifier.
+    #
+    # IANA entries are protocol registries, not numbered standards: the value is
+    # a hierarchical registry slug (`registry` before the single "/", optional
+    # `sub_registry` after it). Both are kept verbatim.
+    class Identifier < ::Pubid::Identifier
+      # The registry slug (e.g. "_6lowpan-parameters"). Required.
+      attribute :registry, :string
+      # The sub-registry slug (e.g. "lowpan_nhc"). nil for top registries; a nil
+      # default means it is dropped from the serialized hash when absent.
+      attribute :sub_registry, :string
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization: maps
+      # the single Registry subclass's polymorphic_name to its class name so a
+      # stored hash rebuilds the correct identifier type via from_hash.
+      IANA_TYPE_MAP = {
+        "pubid:iana:registry" => "Pubid::Iana::Identifiers::Registry",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: IANA_TYPE_MAP
+        map "registry", to: :registry
+        map "sub_registry", to: :sub_registry
+      end
+
+      # Publisher is always "IANA". A plain constant (not a `publisher` method)
+      # so it doesn't shadow the inherited lutaml `publisher` attribute, which
+      # would otherwise fail serialization type validation.
+      PUBLISHER = "IANA"
+
+      # Render-time flag stashed by #to_s; when false, the "IANA " token is
+      # dropped so callers can recover the bare index-key slug.
+      attr_reader :with_publisher
+
+      # The rendered registry code, e.g. "_6lowpan-parameters/lowpan_nhc".
+      def code
+        sub_registry ? "#{registry}/#{sub_registry}" : registry
+      end
+
+      # Basic string representation. Delegates to the renderer. Always emits the
+      # "IANA " token (the authoritative printed form) unless with_publisher is
+      # false, in which case the bare slug is rendered.
+      def to_s(with_publisher: true, **opts)
+        @with_publisher = with_publisher
+        render(format: :human, **opts)
+      end
+
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier;
+      # IANA_TYPE_MAP remains as the key_value polymorphic_map.
+
+      # Parse an IANA identifier string into an identifier object
+      # @param identifier [String] The IANA identifier string to parse
+      # @return [Identifier] The appropriate identifier object
+      def self.parse(identifier)
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse IANA identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

data/lib/pubid/iana/identifiers/registry.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    module Identifiers
+      # The sole IANA identifier type: a protocol registry (optionally with a
+      # sub-registry). Its class name yields the polymorphic `_type` tag
+      # "pubid:iana:registry".
+      #
+      # Examples:
+      #   IANA _6lowpan-parameters
+      #   IANA _6lowpan-parameters/lowpan_nhc
+      class Registry < Identifier
+        # IANA registries carry no revision/stage lifecycle; a single published
+        # typed stage keeps parity with the other flavors' type registries.
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubiana,
+            stage_code: :published,
+            type_code: :iana,
+            abbr: ["IANA"],
+            name: "IANA Registry",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :iana, web: :registry, title: "IANA Registry", short: "IANA" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iana/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    module Identifiers
+      autoload :Registry, "#{__dir__}/identifiers/registry"
+    end
+  end
+end

data/lib/pubid/iana/parser.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Iana
+    # Parslet grammar for IANA registry identifiers.
+    #
+    # Accepts the authoritative printed form "IANA <slug>[/<sub-slug>]" as well
+    # as a bare index-key slug (no "IANA " prefix). The optional prefix is
+    # consumed and discarded — the renderer always re-emits it.
+    #
+    # Slugs use only [a-zA-Z0-9._-] and contain at most one "/", so a plain
+    # character-class repeat parses them; there is no ReDoS surface.
+    class Parser < Parslet::Parser
+      # A single registry slug: letters, digits, dot, underscore, hyphen.
+      rule(:slug) { match['a-zA-Z0-9._\-'].repeat(1) }
+
+      # Optional publisher prefix. The trailing space is required, so a
+      # space-free slug never triggers it; PEG `.maybe` backtracks the whole
+      # sequence if the space is absent (e.g. a slug that happens to start
+      # "IANA...").
+      rule(:iana_prefix) { (str("IANA") >> str(" ")).maybe }
+
+      rule(:identifier) do
+        iana_prefix >>
+          slug.as(:registry) >>
+          (str("/") >> slug.as(:sub_registry)).maybe
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end