pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/easc.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    extend Pubid::PrefixesSupport
+
+    # Leading identifier tokens that an EASC document id can start with.
+    # Both Cyrillic (canonical — ПМГ, РМГ) and Latin transliterations
+    # (PMG, RMG) are accepted; the canonical render is Cyrillic per
+    # mgscatalog.by convention.
+    PREFIXES = ["ПМГ", "РМГ", "PMG", "RMG"].freeze
+
+    autoload :Builder,      "#{__dir__}/easc/builder"
+    autoload :Identifier,   "#{__dir__}/easc/identifier"
+    autoload :Identifiers,  "#{__dir__}/easc/identifiers"
+    autoload :Parser,       "#{__dir__}/easc/parser"
+    autoload :Renderer,     "#{__dir__}/easc/renderer"
+    autoload :UrnGenerator, "#{__dir__}/easc/urn_generator"
+    autoload :UrnParser,    "#{__dir__}/easc/urn_parser"
+
+    # @param identifier [String]
+    # @return [Pubid::Easc::Identifier]
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry.
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Easc::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: series (ПМГ / РМГ / PMG / RMG) → identifier class
+    # @param series [String, Symbol]
+    # @return [Class<Identifier>, nil]
+    def self.identifier_klass_for_series(series)
+      @by_series ||= identifier_types.to_h do |klass|
+        [klass.type[:series].to_s, klass]
+      end
+      @by_series[series.to_s] || @by_series[series.to_s.upcase]
+    end
+  end
+end
+
+Pubid::Registry.register(:easc, Pubid::Easc)

data/lib/pubid/ecma/builder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    # Turns the Parslet parse tree into a concrete identifier object. The class
+    # is chosen by which number key the parser captured.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        klass, attrs =
+          if data[:tr_number]
+            [Identifiers::TechnicalReport, { number: data[:tr_number].to_s }]
+          elsif data[:mem_number]
+            [Identifiers::Memento, { number: data[:mem_number].to_s }]
+          else
+            [Identifiers::Standard, standard_attrs(data)]
+          end
+
+        klass.new(**attrs, **suffix_attrs(data))
+      end
+
+      private
+
+      def standard_attrs(data)
+        attrs = { number: data[:number].to_s }
+        attrs[:part] = data[:part].to_s if data[:part]
+        attrs
+      end
+
+      # ` ed<N>` / ` vol<N>` attach after the type alternation, so a technical
+      # report and a memento carry them exactly as a standard does. An absent
+      # suffix produces no parse key at all, so the attribute stays unset and
+      # drops out of the canonical hash.
+      def suffix_attrs(data)
+        attrs = {}
+        attrs[:edition] = data[:edition].to_s if data[:edition]
+        attrs[:volume] = data[:volume].to_s if data[:volume]
+        attrs
+      end
+    end
+  end
+end

data/lib/pubid/ecma/identifier.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    # Base class for every ECMA identifier AND the flavor's parse entry point —
+    # mirrors Pubid::Jis::Identifier. Concrete identifiers under
+    # Pubid::Ecma::Identifiers descend from this class, so a parsed ECMA id is
+    # an instance of Pubid::Ecma::Identifier. ECMA has no supplement layer.
+    # KEEP THIS CLASS BODY IN ONE FILE, AND NEVER REOPEN IT. `number`, `part`
+    # and `edition` below redeclare attributes the parent ::Pubid::Identifier
+    # types as components, which resolves nondeterministically under
+    # multi-flavor load if a subclass can snapshot a half-built attribute
+    # table. lutaml deep-dups the parent table into each subclass at
+    # class-definition time, and Ruby resolves this superclass constant to
+    # completion before opening any leaf body — so a single, never-reopened
+    # body is what makes the redeclaration safe. (The W3C precedent; IEEE's
+    # split base is the counter-shape.)
+    class Identifier < ::Pubid::Identifier
+      # The document number as a string (preserves any leading zeros). `part`
+      # is only present for standards that split into parts (e.g. ECMA-418-1).
+      attribute :number, :string
+      attribute :part, :string
+      # Edition is relaton's `:ed:` (the index stores {:id, :ed, :vol} and the
+      # YAML has edition.content). It is part of the printed identifier: the
+      # relaton index keys on a bare `to_s`, so without it all 22 editions of
+      # ECMA-74 collapse onto one key. An optional string, because decimal
+      # editions like "5.1" occur. No default, so it drops from the hash when
+      # unset.
+      attribute :edition, :string
+      # Volume is relaton's `:vol:`. Only ECMA-269 edition 3 uses it: its four
+      # volumes share one docidentifier AND one title, so the volume is the only
+      # thing that distinguishes those four index rows. A plain string, the
+      # `number`/`edition` precedent, so it round-trips verbatim.
+      attribute :volume, :string
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization:
+      # maps each subclass's polymorphic_name to its class name so a stored
+      # hash rebuilds the correct identifier type via from_hash.
+      ECMA_TYPE_MAP = {
+        "pubid:ecma:standard" => "Pubid::Ecma::Identifiers::Standard",
+        "pubid:ecma:technical-report" =>
+          "Pubid::Ecma::Identifiers::TechnicalReport",
+        "pubid:ecma:memento" => "Pubid::Ecma::Identifiers::Memento",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: ECMA_TYPE_MAP
+        map "number", to: :number
+        map "part", to: :part
+        map "edition", to: :edition
+        map "volume", to: :volume
+      end
+
+      # Publisher is always "ECMA". 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 = "ECMA"
+
+      # Whether the last `to_s` should include the "ECMA" publisher token.
+      attr_reader :with_publisher
+
+      # Basic string representation. Delegates to renderer. `with_publisher:
+      # false` drops the ECMA token (e.g. "-411", "TR/84").
+      #
+      # The edition and volume suffixes are rendered by DEFAULT and are opted
+      # out of with `to_s(with_edition: false, with_volume: false)`. Both flags
+      # ride in `opts` to the renderer, which owns their defaults — see
+      # Pubid::Ecma::Renderer for why the default is "with".
+      def to_s(with_publisher: true, **opts)
+        @with_publisher = with_publisher
+        render(format: :human, **opts)
+      end
+
+      # Type token that precedes the number ("TR"/"MEM"), or nil for standards.
+      # Overridden by each concrete identifier class.
+      def type_prefix
+        nil
+      end
+
+      # ECMA keeps its publisher in the PUBLISHER constant rather than the
+      # inherited `publisher` attribute, so the base hook — `publisher&.to_s` —
+      # is nil and every ECMA slug would lose its "ecma." segment.
+      def mr_publisher
+        PUBLISHER.downcase
+      end
+
+      # The Builder picks an identifier class; it never sets a `typed_stage`,
+      # so the base hook is always nil. Without this, "ECMA-101" and
+      # "ECMA TR/101" produce the same slug — and `to_slug` is an output
+      # filename, so one document would overwrite the other.
+      def mr_type
+        type_prefix&.downcase
+      end
+
+      # ECMA's `edition` is a plain :string ("3", "5.1"), not a
+      # Components::Edition, so the base hook's `edition&.number` raises
+      # NoMethodError on every edition-bearing identifier.
+      def mr_edition
+        mr_marker("ed", edition)
+      end
+
+      # Volume is identity-bearing (ECMA-269 ed3 vol1..vol4 are four distinct
+      # documents), so it must reach the MR string as well as `to_s` and the
+      # URN. Fills the shared `mr_volume` slot in Renderers::MrString.
+      def mr_volume
+        mr_marker("vol", volume)
+      end
+
+      # Parse an ECMA identifier string into an identifier object.
+      # @param identifier [String] The ECMA identifier string to parse
+      # @return [Identifier] The appropriate identifier object
+      # @raise [Pubid::Errors::InvalidInputError]
+      #   If the input exceeds MAX_INPUT_LENGTH
+      # @raise [Pubid::Errors::ParseError] If parsing fails
+      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(identifier)
+        Builder.build(parsed)
+      end
+
+      private
+
+      # Renderers::MrString joins SEGMENTS with ".", so a dot inside one would
+      # break the documented segment structure — hence "ed5-1" for edition
+      # "5.1". Sanitising by CHARSET rather than by an enumerated escape list,
+      # so a value added later cannot leak an unsafe character (the BIPM
+      # `mr_slug` precedent).
+      #
+      # The MR may be lossy here because nothing parses an ECMA MR back
+      # (`Parsers::MrString::FLAVOR_MAP` has no ECMA entry). The URN, which
+      # UrnParser inverts, keeps the dot instead.
+      def mr_marker(label, value)
+        return nil if value.nil? || value.to_s.empty?
+
+        "#{label}#{value.to_s.downcase.gsub(/[^a-z0-9]+/, '-')}"
+      end
+    end
+  end
+end

data/lib/pubid/ecma/identifiers/memento.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    module Identifiers
+      # Memento identifier type.
+      # Format: ECMA MEM/<year>. Example: ECMA MEM/1970
+      class Memento < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :mem,
+            stage_code: :published,
+            type_code: :ecma,
+            abbr: ["MEM"],
+            name: "Memento",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :mem, web: :memento, title: "Memento", short: "MEM" }
+        end
+
+        def type_prefix
+          "MEM"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    module Identifiers
+      # Default ECMA identifier type (no type token).
+      # Examples: ECMA-411, ECMA-418-1
+      class Standard < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :standard,
+            stage_code: :published,
+            type_code: :ecma,
+            abbr: ["ECMA"],
+            name: "Standard",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :standard, web: :standard, title: "Standard", short: "ECMA" }
+        end
+
+        # No type token for standards.
+        def type_prefix
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ecma/identifiers/technical_report.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    module Identifiers
+      # Technical Report identifier type.
+      # Format: ECMA TR/<number>. Example: ECMA TR/101
+      class TechnicalReport < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :tr,
+            stage_code: :published,
+            type_code: :ecma,
+            abbr: ["TR"],
+            name: "Technical Report",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :tr, web: :technical_report, title: "Technical Report",
+            short: "TR" }
+        end
+
+        def type_prefix
+          "TR"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ecma/identifiers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    module Identifiers
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+      autoload :Memento, "#{__dir__}/identifiers/memento"
+    end
+  end
+end

data/lib/pubid/ecma/parser.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Ecma
+    # Parslet grammar for ECMA identifiers.
+    #
+    # Four printed forms:
+    #   ECMA-411          standard
+    #   ECMA-418-1        standard with part
+    #   ECMA TR/101       technical report
+    #   ECMA MEM/1970     memento
+    #
+    # Any of them may carry an edition and a volume, in that order:
+    #   ECMA-269 ed3      third edition
+    #   ECMA-402 ed5.1    decimal edition (real: ECMA-402)
+    #   ECMA-269 ed3 vol2 second volume of the third edition
+    #
+    # Each branch captures its number under a distinct key so the builder can
+    # pick the identifier class without a separate type token. Numbers are kept
+    # as strings to preserve any leading zeros.
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:digits) { match["0-9"].repeat(1) }
+
+      rule(:prefix) { str("ECMA") }
+
+      rule(:tr) { str(" TR/") >> digits.as(:tr_number) }
+
+      rule(:mem) { str(" MEM/") >> digits.as(:mem_number) }
+
+      # Standards print with a hyphen ("ECMA-6"), but references are commonly
+      # written with a space ("ECMA 6"). Both parse; the renderer normalises to
+      # the hyphen, so the space form round-trips as "ECMA-6" by design and must
+      # never enter the byte-exact `pass` fixtures.
+      rule(:standard_separator) { str("-") | str(" ") }
+
+      rule(:standard) do
+        standard_separator >> digits.as(:number) >>
+          (str("-") >> digits.as(:part)).maybe
+      end
+
+      # Editions are not all integers: ECMA-402 ed5.1 is a real document. The
+      # value is stored verbatim so it renders and serializes unchanged.
+      rule(:edition_number) { digits >> (str(".") >> digits).repeat(0) }
+
+      rule(:edition) { str(" ed") >> edition_number.as(:edition) }
+
+      rule(:volume) { str(" vol") >> digits.as(:volume) }
+
+      # The suffixes attach AFTER the type alternation, so a technical report
+      # and a memento carry them exactly as a standard does.
+      #
+      # Two PEG facts this arrangement depends on:
+      #
+      # 1. `standard` cannot shadow " TR/" or " MEM/", because after the space
+      #    it demands a digit and "T"/"M" are not digits. Keeping tr|mem first
+      #    is belt-and-braces; the DISJOINT FIRST CHARACTER is the load-bearing
+      #    invariant.
+      # 2. Appending a sequence moves the alternation out of tail position, so
+      #    Parslet no longer threads consume_all into it and will not backtrack
+      #    into an alternative that already succeeded. A future branch that
+      #    could match a proper prefix of another branch's input would now fail
+      #    the whole parse instead of being rescued by the next alternative.
+      rule(:identifier) do
+        prefix >> (tr | mem | standard) >> edition.maybe >> volume.maybe
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/ecma/renderer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    # Human-readable renderer for ECMA identifiers.
+    #
+    # Produces strings like:
+    #   "ECMA-411"           standard
+    #   "ECMA-418-1"         standard with part
+    #   "ECMA TR/101"        technical report
+    #   "ECMA MEM/1970"      memento
+    #   "ECMA-269 ed3 vol2"  with the edition and volume suffixes
+    #
+    # With `with_publisher: false` the leading ECMA token is dropped, yielding
+    # "-411" / "TR/101" / "MEM/1970".
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "ECMA"
+
+      # `with_edition` and `with_volume` default to TRUE — the inverse of
+      # pubid's usual opt-in, deliberately. `Relaton::Index::Type#add_or_update`
+      # keys on a BARE `id.to_s` and cannot pass options, so the default
+      # rendering is what the index keys on, and it has to be unique per row.
+      # With the edition omitted, all 22 editions of ECMA-74 collapsed onto one
+      # key and 383 of the 804 published rows were dropped silently.
+      #
+      # Per-flavor divergence in these defaults is the established pattern:
+      # Pubid::Tgpp defaults `with_publisher` to false and Pubid::W3c to true,
+      # each for its own consumer's reason.
+      def render(context: nil, with_edition: true, with_volume: true, **_opts)
+        id = @id
+        # Standard joins the publisher directly ("ECMA-411"); TR/MEM separate it
+        # with a space ("ECMA TR/101"). type_prefix is nil only for standards.
+        sep = id.type_prefix.nil? ? "" : " "
+        core = id.type_prefix.nil? ? standard_core(id) : typed_core(id)
+        result = with_publisher?(id) ? "#{PUBLISHER}#{sep}#{core}" : core
+        result + suffixes(id, with_edition, with_volume)
+      end
+
+      private
+
+      # " ed<edition>" then " vol<volume>", each only when the identifier
+      # carries it and the caller has not opted out. The order is canonical:
+      # the grammar accepts the volume only after the edition.
+      def suffixes(id, with_edition, with_volume)
+        out = +""
+        out << " ed#{id.edition}" if with_edition && id.edition
+        out << " vol#{id.volume}" if with_volume && id.volume
+        out
+      end
+
+      # Standard: "-<number>[-<part>]".
+      def standard_core(id)
+        core = "-#{id.number}"
+        id.part ? "#{core}-#{id.part}" : core
+      end
+
+      # Technical Report / Memento: "<TYPE>/<number>".
+      def typed_core(id)
+        "#{id.type_prefix}/#{id.number}"
+      end
+
+      def with_publisher?(id)
+        id.with_publisher != false
+      end
+    end
+  end
+end

data/lib/pubid/ecma/urn_generator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    # Emits
+    # `urn:ecma:<tag>:<number>[:part-<part>][:ed-<edition>][:vol-<volume>]`,
+    # where the tag is bare for standards, "tr" for technical reports and "mem"
+    # for mementos:
+    #   ECMA-411          -> urn:ecma:411
+    #   ECMA-418-1        -> urn:ecma:418:part-1
+    #   ECMA TR/101       -> urn:ecma:tr:101
+    #   ECMA MEM/1970     -> urn:ecma:mem:1970
+    #   ECMA-269 ed3 vol2 -> urn:ecma:269:ed-3:vol-2
+    #   ECMA-402 ed5.1    -> urn:ecma:402:ed-5.1
+    #
+    # The edition and volume segments are additive: they only ever split a
+    # collision, so a URN minted before they existed still reads back (UrnParser
+    # probes for the labelled prefix). They are needed because edition and
+    # volume are identity-bearing — without them 804 published documents share
+    # 421 URNs.
+    #
+    # The dot of a decimal edition is KEPT: "." is `unreserved` in RFC 8141, and
+    # the URN has an inverse, so it must be lossless. (The MR string, which has
+    # no inverse, collapses it to "ed5-1" instead.)
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "ecma", identifier.type_prefix&.downcase,
+                 identifier.number.to_s]
+        parts.concat(labelled_segments)
+        parts.compact.join(":")
+      end
+
+      private
+
+      # Every optional field carries its own label, so a URN written before a
+      # given label existed still reads back (UrnParser probes for the prefix).
+      def labelled_segments
+        {
+          "part" => identifier.part,
+          "ed" => identifier.edition,
+          "vol" => identifier.volume,
+        }.filter_map { |label, value| "#{label}-#{value}" if value }
+      end
+    end
+  end
+end

data/lib/pubid/ecma/urn_parser.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    # Parses ECMA URNs back into identifiers, inverting {UrnGenerator}.
+    #
+    # Examples:
+    #   urn:ecma:411            -> ECMA-411
+    #   urn:ecma:418:part-1     -> ECMA-418-1
+    #   urn:ecma:tr:101         -> ECMA TR/101
+    #   urn:ecma:mem:1970       -> ECMA MEM/1970
+    #   urn:ecma:269:ed-3:vol-2 -> ECMA-269 ed3 vol2
+    #
+    # Every trailing segment is consumed only if it carries its own label, so a
+    # URN written before the edition and volume segments existed still reads
+    # back with both nil.
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        parts = split_parts(strip_namespace(urn))
+        tag = %w[tr mem].include?(parts.first) ? parts.shift : nil
+        number = parts.shift
+        part = shift_labelled(parts, "part-")
+        edition = shift_labelled(parts, "ed-")
+        volume = shift_labelled(parts, "vol-")
+        flavor_parse(reconstruct(tag, number, part, edition, volume))
+      end
+
+      private
+
+      # Consume the next segment only if it carries `label`. `delete_prefix`,
+      # not `sub`, so a label-shaped substring later in the value is untouched.
+      def shift_labelled(parts, label)
+        return nil unless parts.first&.start_with?(label)
+
+        parts.shift.delete_prefix(label)
+      end
+
+      # Rebuild the printed identifier string from the URN fields.
+      def reconstruct(tag, number, part, edition, volume)
+        base = case tag
+               when "tr" then "ECMA TR/#{number}"
+               when "mem" then "ECMA MEM/#{number}"
+               else part ? "ECMA-#{number}-#{part}" : "ECMA-#{number}"
+               end
+        base += " ed#{edition}" if edition
+        base += " vol#{volume}" if volume
+        base
+      end
+    end
+  end
+end

data/lib/pubid/ecma.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    extend Pubid::PrefixesSupport
+
+    # Sole ECMA publisher token (see the parser's `prefix` rule). Document types
+    # (TR/MEM) follow the ECMA prefix as type tokens and are excluded.
+    PREFIXES = ["ECMA"].freeze
+
+    autoload :Builder, "#{__dir__}/ecma/builder"
+    autoload :Identifier, "#{__dir__}/ecma/identifier"
+    autoload :Identifiers, "#{__dir__}/ecma/identifiers"
+    autoload :Parser, "#{__dir__}/ecma/parser"
+    autoload :Renderer, "#{__dir__}/ecma/renderer"
+    autoload :UrnGenerator, "#{__dir__}/ecma/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ecma/urn_parser"
+
+    # Parse an ECMA identifier string
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Ecma::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    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.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+# Register ECMA flavor with the registry
+Pubid::Registry.register(:ecma, Pubid::Ecma)