pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

data/lib/pubid/iec/builder.rb

@@ -1,25 +1,16 @@
-require_relative "../components/publisher"
 # frozen_string_literal: true
-require_relative "../components/code"
-require_relative "../components/date"
 
 module Pubid
   module Iec
     class Builder < Pubid::Builder::Base
-      def initialize(scheme)
-        @scheme = scheme
-      end
-
       def locate_identifier_klass(parsed_hash)
         # Check for working programme
         if parsed_hash[:wp_stage]
-          require_relative "identifiers/working_document"
           return Identifiers::WorkingDocument
         end
 
         # Check for working document
         if parsed_hash[:technical_committee] && parsed_hash[:wd_number]
-          require_relative "identifiers/working_document"
           return Identifiers::WorkingDocument
         end
 
@@ -27,7 +18,8 @@ module Pubid
         # :type_with_stage will be nil if it is an IS.
         typed_stage = locate_typed_stage(parsed_hash[:type_with_stage])
 
-        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+        Pubid::Iec.locate_type(typed_stage.type_code) ||
+          raise(ArgumentError, "Unknown type code: #{typed_stage.type_code}")
       end
 
       def build(parsed_hash)
@@ -55,7 +47,8 @@ module Pubid
 
           # Locate the supplement identifier class
           typed_stage = locate_typed_stage(supplement_type)
-          identifier_class = @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+          identifier_class = Pubid::Iec.locate_type(typed_stage.type_code) ||
+            raise(ArgumentError, "Unknown type code: #{typed_stage.type_code}")
 
           # Create the supplement identifier
           supplement = identifier_class.new
@@ -96,14 +89,11 @@ module Pubid
 
         if is_fragment
           # For FRAG typed stages, look up the fragment's own typed stage
-          begin
-            fragment_typed_stage = @scheme.locate_typed_stage_by_abbr(
-              parsed_hash[:type_with_stage].to_s,
-            )
-          rescue ArgumentError
-            # FRAGC is a rendering notation, not a typed stage abbreviation
-            fragment_typed_stage = @scheme.locate_typed_stage_by_abbr("FRAG")
-          end
+          fragment_typed_stage = Pubid::Iec.locate_stage(parsed_hash[:type_with_stage])
+
+          # FRAGC is a rendering notation, not a typed stage abbreviation;
+          # fall back to the canonical "FRAG" typed stage
+          fragment_typed_stage ||= Pubid::Iec.locate_stage("FRAG")
 
           # For FRAG/FRAGC, we need to build the base Amendment/Corrigendum
           # then wrap it with FragmentIdentifier
@@ -158,7 +148,6 @@ module Pubid
 
         # Detect rendering style from parsed abbreviation
         if identifier.class.attributes.key?(:rendering_style) && identifier.typed_stage
-          require_relative "rendering_style"
           ts = identifier.typed_stage
 
           # Detect IEC format from parsed abbreviation
@@ -179,7 +168,7 @@ module Pubid
           with_language_code = if langs&.any?
                                  # Check if original_code was single-char (E, F, R, A, S, D)
                                  first_lang = langs.first
-                                 if first_lang.is_a?(Components::Language) && first_lang.original_code && first_lang.original_code.length == 1
+                                 if first_lang.is_a?(::Pubid::Components::Language) && first_lang.original_code && first_lang.original_code.length == 1
                                    :single
                                  else
                                    :iso # 2-char codes (en, fr, ru, ar, es, de)
@@ -202,7 +191,7 @@ module Pubid
 
         # After building base identifier, apply wrappers
         if fragment_type_data && fragment_number_data
-          frag_ts = @scheme.locate_typed_stage_by_abbr("FRAG")
+          frag_ts = Pubid::Iec.locate_stage("FRAG")
           identifier = wrap_with_fragment(identifier, fragment_number_data.to_s,
                                           nil, frag_ts)
         end
@@ -229,11 +218,25 @@ module Pubid
         end
       end
 
+      # The IEC builder's own `build` method drives identifier construction
+      # (it locates the right class per parsed hash), so the parent class's
+      # `@identifier_class` slot is never read. Provide a placeholder so
+      # `Builder.new` doesn't fail with NotImplementedError.
+      def default_identifier_class
+        Identifiers::InternationalStandard
+      end
+
+      # Look up a typed stage by abbreviation via the self-describing
+      # `Pubid::Iec` module instead of an injected scheme instance.
+      def locate_typed_stage(typed_stage_string)
+        typed_stage_string = "" if typed_stage_string.nil?
+        Pubid::Iec.locate_stage(typed_stage_string) ||
+          raise(ArgumentError, "Unknown type abbreviation: '#{typed_stage_string}'")
+      end
+
       # Wrap identifier with FragmentIdentifier for /FRAGN notation
       def wrap_with_fragment(base_identifier, fragment_number,
-edition_data = nil, typed_stage = nil)
-        require_relative "identifiers/fragment_identifier"
-
+      edition_data = nil, typed_stage = nil)
         fragment = Identifiers::FragmentIdentifier.new(
           base_identifier: base_identifier,
           fragment_number: fragment_number,
@@ -252,8 +255,6 @@ edition_data = nil, typed_stage = nil)
 
       # Wrap identifier with SheetIdentifier for /N:YEAR notation
       def wrap_with_sheet(base_identifier, sheet_number, sheet_year)
-        require_relative "identifiers/sheet_identifier"
-
         # Only pass year if it's present
         year_value = sheet_year&.to_s
 
@@ -272,10 +273,6 @@ edition_data = nil, typed_stage = nil)
 
       # Wrap identifier with ConsolidatedIdentifier for +AMD chains
       def wrap_with_consolidated(base_identifier, supplements_data)
-        require_relative "identifiers/consolidated_identifier"
-        require_relative "identifiers/amendment"
-        require_relative "identifiers/corrigendum"
-
         supplements = supplements_data.filter_map do |supp|
           type = supp[:supplement_type].to_s
           number = supp[:supplement_number].to_s
@@ -302,13 +299,10 @@ edition_data = nil, typed_stage = nil)
         )
       end
 
-      # Wrap identifier with VapIdentifier for CSV/CMV/RLV/SER suffix
+      # Wrap identifier with VapIdentifier for one or more VAP codes
+      # (e.g. "CSV" or "EXV-CMV").
       def wrap_with_vap(base_identifier, vap_suffix_data)
-        require_relative "identifiers/vap_identifier"
-        require_relative "identifiers/consolidated_identifier"
-        require_relative "components/vap_suffix"
-
-        vap_suffix = Components::VapSuffix.new(code: vap_suffix_data.to_s)
+        vap = vap_suffix_data.to_s.split("-")
 
         # Extract edition - need to go deep for ConsolidatedIdentifier
         edition = nil
@@ -326,7 +320,7 @@ edition_data = nil, typed_stage = nil)
 
         Identifiers::VapIdentifier.new(
           base_identifier: base_identifier,
-          vap_suffix: vap_suffix,
+          vap: vap,
           edition: edition,
         )
       end
@@ -337,6 +331,12 @@ edition_data = nil, typed_stage = nil)
         super
       end
 
+      # IEC normalizes em/en dashes to hyphens but preserves slashes and
+      # spaces, which can be semantically meaningful in IEC identifiers.
+      def normalize_number_with_part(value)
+        value.to_s.tr(Parser::DASH_CHARS.join, "-")
+      end
+
       def cast(type, value)
         case type
         when :base_identifier
@@ -374,28 +374,7 @@ edition_data = nil, typed_stage = nil)
           # or "60038-1" ('1' is part)
           # or "60038-1-2" ('1' is part, '2' is subpart)
           # or "29110-5-1-1" ('5' is part, '1-1' is subpart)
-
-          # Split the number into parts
-          normalized_value = value.to_s.tr(Parser::DASH_CHARS.join, "-")
-
-          parts = normalized_value.split("-")
-          number = parts.shift # The first part is always the number
-          part = parts.shift # The second part is the part, if present
-          subpart = parts.any? ? parts.join("-") : nil # The remaining parts form the subpart, if present
-
-          part = convert_roman_to_integer(part)
-
-          code_hash = { number: Components::Code.new(value: number) }
-
-          if part
-            code_hash[:part] = Components::Code.new(value: part)
-          end
-
-          if subpart
-            code_hash[:subpart] = Components::Code.new(value: subpart)
-          end
-
-          code_hash
+          parse_number_with_part(value, code_class: Components::Code)
 
         when :type_with_stage
           # "WD"
@@ -416,13 +395,17 @@ edition_data = nil, typed_stage = nil)
           }
         when :stage_iteration
           # "1" or "2"
-          Components::Code.new(value: value.to_s)
+          Pubid::Components::Iteration.new(number: value.to_s)
 
         when :date
           parse_date(value)
 
         when :edition
-          Pubid::Components::Edition.new(number: value)
+          # Coerce to String: the parsed value may be a Parslet::Slice, which
+          # Edition.number (Type::Value) would store verbatim and serialize as a
+          # !ruby/object:Parslet::Slice node — unloadable by the index reader's
+          # YAML.safe_load(permitted_classes: [Symbol]).
+          Pubid::Components::Edition.new(number: value&.to_s)
 
         when :sheet_number
           value.to_s
@@ -434,7 +417,8 @@ edition_data = nil, typed_stage = nil)
           parse_languages(value)
 
         when :all_parts
-          Pubid::Components::Locality.new(all_parts: true)
+          # Set all_parts boolean attribute directly on identifier (matches ISO builder)
+          true
 
         when :database
           # Database flag - return true if DB suffix present
@@ -444,8 +428,7 @@ edition_data = nil, typed_stage = nil)
         when :joint_identifier
           case value[:publisher]
           when "ISO"
-            require_relative "../iso/builder"
-            Iso::Builder.new(Iso::Scheme).build(value)
+            Pubid::Iso.build_from_parse(value)
           end
 
         else

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

@@ -1,57 +1,34 @@
-require "lutaml/model"
 # frozen_string_literal: true
 
 module Pubid
   module Iec
     module Components
-      class Code < Lutaml::Model::Serializable
-        attribute :prefix, :string, default: -> {}
-        attribute :number, :string
-        attribute :part, :string, default: -> {}
-
-        def initialize(value: nil, number: nil, prefix: nil, part: nil)
-          # Support both 'value' (for convenience) and 'number' (explicit)
-          @number = value || number
-          @prefix = prefix
-          @part = part
-        end
-
+      # Code component for IEC identifiers.
+      #
+      # Inherits +value+ and +prefix+ from the shared Code; overrides
+      # rendering to place the prefix (e.g. "TR", "TS") before the value.
+      class Code < ::Pubid::Components::Code
         def to_s
           result = ""
           result += "#{prefix} " if prefix
-          result += number
-          result += "-#{part}" if part
+          result += value.to_s
           result
         end
 
-        def full_code
-          to_s
-        end
+        alias full_code to_s
 
         # Parse IEC code formats:
         # - "60034" (just number)
-        # - "60034-1" (number with part)
         # - "TR 61000" (with prefix)
         # - "TS 62443" (with prefix)
         def self.parse(string)
           parts = string.strip.split(" ", 2)
 
           if parts.size == 2
-            # Has prefix: "TR 61000-1-2"
-            prefix = parts[0]
-            number_part = parts[1]
+            new(prefix: parts[0], value: parts[1])
           else
-            # No prefix: "60034-1"
-            prefix = nil
-            number_part = parts[0]
+            new(value: parts[0])
           end
-
-          # Split number and part
-          number_parts = number_part.split("-", 2)
-          number = number_parts[0]
-          part = number_parts[1]
-
-          new(prefix: prefix, number: number, part: part)
         end
       end
     end

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

@@ -4,7 +4,7 @@ require "lutaml/model"
 module Pubid
   module Iec
     module Components
-      class Publisher < Lutaml::Model::Serializable
+      class Publisher < ::Pubid::Components::Publisher
         PUBLISHERS = {
           "IEC" => "International Electrotechnical Commission",
           "ISO/IEC" => "ISO/IEC Joint Technical Committee",

data/lib/pubid/iec/components.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    module Components
+      autoload :Code, "#{__dir__}/components/code"
+      autoload :ConsolidatedAmendment, "#{__dir__}/components/consolidated_amendment"
+      autoload :Publisher, "#{__dir__}/components/publisher"
+      autoload :Sheet, "#{__dir__}/components/sheet"
+      autoload :TrfInfo, "#{__dir__}/components/trf_info"
+      autoload :VapSuffix, "#{__dir__}/components/vap_suffix"
+    end
+  end
+end

data/lib/pubid/iec/identifier.rb

@@ -1,11 +1,269 @@
-require_relative "../identifier"
 # frozen_string_literal: true
-require_relative "../components/typed_stage"
 
 module Pubid
   module Iec
+    # Mixin for pure wrapper identifiers (Vap/Consolidated/Sheet) whose common
+    # ID fields are delegated to a wrapped base. lutaml merges a subclass's
+    # key_value block onto the parent's, so without this the delegated fields
+    # would serialize twice — once at the wrapper's top level and once inside
+    # "base". No-op the delegated maps so they serialize once. (Mirrors
+    # Iso::BundledIdentifier.) Fragment keeps its own stage/edition, so it
+    # suppresses a subset inline instead of including this.
+    module DelegatedFieldSuppression
+      def number_to_kv(_model, _doc); end
+      def part_to_kv(_model, _doc); end
+      def subpart_to_kv(_model, _doc); end
+      def stage_iteration_to_kv(_model, _doc); end
+      def year_to_kv(_model, _doc); end
+      def publisher_to_kv(_model, _doc); end
+      def copublishers_to_kv(_model, _doc); end
+      def stage_to_kv(_model, _doc); end
+    end
+
     class Identifier < ::Pubid::Identifier
+      # Override base types with IEC-specific ones. publisher defaults to the
+      # type's implied publisher (IEC), so an omitted publisher key reconstructs
+      # correctly on from_hash. number/part/subpart are IEC codes.
+      attribute :publisher, ::Pubid::Iec::Components::Publisher,
+                default: -> { self.class.default_publisher }
+      attribute :copublishers, ::Pubid::Iec::Components::Publisher,
+                collection: true
+      attribute :number, ::Pubid::Iec::Components::Code
+      attribute :part, ::Pubid::Iec::Components::Code
+      attribute :subpart, ::Pubid::Iec::Components::Code
+
+      # The publisher implied when none is serialized (IEC for every type).
+      def self.default_publisher
+        ::Pubid::Iec::Components::Publisher.new(body: "IEC")
+      end
+
+      # typed_stage is the single source of truth for stage (and, with the
+      # class, the doctype). Default to the class's published typed_stage so an
+      # omitted "stage" key reconstructs the published state on from_hash.
+      attribute :typed_stage, ::Pubid::Components::TypedStage,
+                default: -> { self.class.published_typed_stage }
+
+      # The class's published typed_stage (canonical surface form), or nil for
+      # types without a published stage.
+      def self.published_typed_stage
+        return nil unless const_defined?(:TYPED_STAGES)
+
+        ts = self::TYPED_STAGES.find { |t| t.stage_code.to_s == "published" }
+        return nil unless ts
+
+        ts = ts.dup
+        ts.original_abbr = ts.canonical_abbreviation
+        ts
+      end
+
+      # type and generic stage are derived from typed_stage, never stored — so
+      # the doctype (fixed by the class / _type) can't be lost when "stage" is
+      # omitted for the published default.
+      def type
+        typed_stage&.to_type
+      end
+
+      def stage
+        typed_stage&.to_stage
+      end
+
+      # Polymorphic type map for lutaml::Model key_value serialization. Maps
+      # polymorphic_name -> class name for from_hash dispatch. Includes the
+      # compound wrappers (Consolidated/Vap/Sheet) and the synthetic
+      # SingleIdentifier base, which appear as nested `_type` values even though
+      # they aren't identifier_types. Validated against build_type_map by spec.
+      IEC_TYPE_MAP = {
+        "pubid:iec:international-standard" => "Pubid::Iec::Identifiers::InternationalStandard",
+        "pubid:iec:technical-specification" => "Pubid::Iec::Identifiers::TechnicalSpecification",
+        "pubid:iec:technical-report" => "Pubid::Iec::Identifiers::TechnicalReport",
+        "pubid:iec:publicly-available-specification" => "Pubid::Iec::Identifiers::PubliclyAvailableSpecification",
+        "pubid:iec:guide" => "Pubid::Iec::Identifiers::Guide",
+        "pubid:iec:operational-document" => "Pubid::Iec::Identifiers::OperationalDocument",
+        "pubid:iec:component-specification" => "Pubid::Iec::Identifiers::ComponentSpecification",
+        "pubid:iec:conformity-assessment" => "Pubid::Iec::Identifiers::ConformityAssessment",
+        "pubid:iec:societal-technology-trend-report" => "Pubid::Iec::Identifiers::SocietalTechnologyTrendReport",
+        "pubid:iec:systems-reference-document" => "Pubid::Iec::Identifiers::SystemsReferenceDocument",
+        "pubid:iec:technology-report" => "Pubid::Iec::Identifiers::TechnologyReport",
+        "pubid:iec:test-report-form" => "Pubid::Iec::Identifiers::TestReportForm",
+        "pubid:iec:white-paper" => "Pubid::Iec::Identifiers::WhitePaper",
+        "pubid:iec:working-document" => "Pubid::Iec::Identifiers::WorkingDocument",
+        "pubid:iec:amendment" => "Pubid::Iec::Identifiers::Amendment",
+        "pubid:iec:corrigendum" => "Pubid::Iec::Identifiers::Corrigendum",
+        "pubid:iec:interpretation-sheet" => "Pubid::Iec::Identifiers::InterpretationSheet",
+        "pubid:iec:fragment-identifier" => "Pubid::Iec::Identifiers::FragmentIdentifier",
+        "pubid:iec:consolidated-identifier" => "Pubid::Iec::Identifiers::ConsolidatedIdentifier",
+        "pubid:iec:vap-identifier" => "Pubid::Iec::Identifiers::VapIdentifier",
+        "pubid:iec:sheet-identifier" => "Pubid::Iec::Identifiers::SheetIdentifier",
+        "pubid:iec:base" => "Pubid::Iec::Identifiers::Base",
+        "pubid:iec:single-identifier" => "Pubid::Iec::SingleIdentifier",
+      }.freeze
+
+      # Build the type map from the live class list, for the validation spec.
+      def self.build_type_map
+        types = Pubid::Iec.identifier_types
+        extra = [Identifiers::ConsolidatedIdentifier, Identifiers::VapIdentifier,
+                 Identifiers::SheetIdentifier, Identifiers::Base, SingleIdentifier]
+        (types + extra).uniq.to_h { |klass| [klass.polymorphic_name, klass.name] }
+      end
+
+      # The base Pubid::Identifier no longer auto-maps attributes, so each
+      # flavor's top class declares its own key_value mapping. Subclasses merge
+      # their own blocks on top of this one (e.g. SupplementIdentifier adds
+      # base; VapIdentifier adds vap), so list every base attribute IEC
+      # serializes here once. Code/Date are flattened to plain scalars; the
+      # verbose type/stage trees are not mapped (type/stage are recomputed from
+      # typed_stage, which serializes as just its code under "stage").
+      key_value do
+        map "_type", to: :_type, polymorphic_map: IEC_TYPE_MAP
+        # Code components serialize as their plain string value, not {value,...}.
+        map "number", with: { to: :number_to_kv, from: :number_from_kv }
+        map "part", with: { to: :part_to_kv, from: :part_from_kv }
+        map "subpart", with: { to: :subpart_to_kv, from: :subpart_from_kv }
+        map "stage_iteration",
+            with: { to: :stage_iteration_to_kv, from: :stage_iteration_from_kv }
+        # IEC dates are year-only, so flatten the Date component to a scalar year.
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "edition", to: :edition, render_default: false
+        map "languages", to: :languages, render_default: false
+        # publisher emitted only when the primary isn't the IEC default;
+        # copublishers (the other bodies) as an array, omitted when empty.
+        map "publisher", with: { to: :publisher_to_kv, from: :publisher_from_kv }
+        map "copublishers",
+            with: { to: :copublishers_to_kv, from: :copublishers_from_kv }
+        # `type` and generic `stage` are fully derived from `typed_stage`, so we
+        # serialize only the unique typed-stage code under "stage" and recompute
+        # the rest on load. _type already pins the document type.
+        map "stage", with: { to: :stage_to_kv, from: :stage_from_kv }
+        # Omit the `false` default; only the meaningful `true` is serialized.
+        map "all_parts", with: { to: :all_parts_to_kv, from: :all_parts_from_kv }
+      end
+
+      # --- Code components <-> plain string ---
+      def number_to_kv(model, doc) = emit_code(doc, "number", model.number)
+      def number_from_kv(model, value) = model.number = build_code(value)
+      def part_to_kv(model, doc) = emit_code(doc, "part", model.part)
+      def part_from_kv(model, value) = model.part = build_code(value)
+      def subpart_to_kv(model, doc) = emit_code(doc, "subpart", model.subpart)
+      def subpart_from_kv(model, value) = model.subpart = build_code(value)
+
+      def emit_code(doc, key, code)
+        v = code.is_a?(::Pubid::Components::Code) ? code.value : code
+        return if v.nil? || v.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, v.to_s))
+      end
+
+      def build_code(value)
+        return if value.nil? || value.to_s.empty?
+
+        ::Pubid::Iec::Components::Code.new(value: value.to_s)
+      end
+
+      def stage_iteration_to_kv(model, doc)
+        iter = model.stage_iteration
+        v = iter.is_a?(::Pubid::Components::Iteration) ? iter.number : iter
+        return if v.nil? || v.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("stage_iteration",
+                                                              v.to_s))
+      end
+
+      def stage_iteration_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
+
+        model.stage_iteration =
+          ::Pubid::Components::Iteration.new(number: value.to_s)
+      end
+
+      # --- date <-> scalar year (IEC dates are year-only) ---
+      def year_to_kv(model, doc)
+        y = model.date&.year
+        return if y.nil? || y.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("year", y.to_s))
+      end
+
+      def year_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
+
+        (model.date ||= ::Pubid::Components::Date.new).year = value.to_s
+      end
+
+      # --- publisher: primary only when non-default; copublishers as a list ---
+      def publisher_to_kv(model, doc)
+        pub = model.publisher&.body
+        return if pub.nil? || pub == model.class.default_publisher&.body
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("publisher", pub))
+      end
+
+      def publisher_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
+
+        model.publisher = ::Pubid::Iec::Components::Publisher.new(body: value.to_s)
+      end
+
+      def copublishers_to_kv(model, doc)
+        cp = model.copublishers
+        return unless cp&.any?
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("copublishers", cp.map(&:body)),
+        )
+      end
+
+      def copublishers_from_kv(model, value)
+        list = Array(value).map(&:to_s)
+        return unless list.any?
+
+        model.copublishers = list.map do |cp|
+          ::Pubid::Iec::Components::Publisher.new(body: cp)
+        end
+      end
+
+      # --- all_parts: omit the false default ---
+      def all_parts_to_kv(model, doc)
+        return unless model.all_parts
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("all_parts", true))
+      end
+
+      def all_parts_from_kv(model, value)
+        model.all_parts = value
+      end
+
+      # Serialize typed_stage as just its unique code (e.g. "cd", "fdis"); the
+      # published default is omitted (recomputed from the class on load).
+      def stage_to_kv(model, doc)
+        ts = model.typed_stage
+        return unless ts&.code
+        return if ts.stage_code.to_s == "published"
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("stage", ts.code.to_s),
+        )
+      end
+
+      # Resolve the typed-stage code back within this identifier's class.
+      def stage_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
+
+        ts = (model.class.const_defined?(:TYPED_STAGES) &&
+              model.class::TYPED_STAGES.find { |t| t.code.to_s == value.to_s }) ||
+             Pubid::Iec.all_typed_stages.find { |t| t.code.to_s == value.to_s }
+        return unless ts
+
+        ts = ts.dup
+        ts.original_abbr = ts.canonical_abbreviation
+        model.typed_stage = ts
+      end
+
       def self.parse(string)
+        # Route URN strings to the URN parser (mirrors Iso::Identifier.parse)
+        if Pubid::FormatDetector.detect(string) == :urn
+          return Pubid::Iec::UrnParser.parse(string)
+        end
+
         # Apply legacy update_codes normalization first, before any other preprocessing
         normalized = Core::UpdateCodes.apply(string, :iec)
         parsed = Pubid::Iec::Parser.new.parse(normalized)
@@ -14,7 +272,22 @@ module Pubid
                 "Invalid identifier format"
         end
 
-        Pubid::Iec::Builder.new(Pubid::Iec::Scheme).build(parsed)
+        Pubid::Iec::Builder.new.build(parsed)
+      end
+
+      # lutaml's polymorphic key_value mapping reads `_type` only to validate; it
+      # does not re-instantiate the concrete subclass on root deserialization. So
+      # `Identifier.from_hash(amendment_hash)` would return a bare Identifier and
+      # drop base_identifier. Route by `_type` to the right subclass and let its
+      # (inherited) from_hash do the real work, mirroring ISO/JIS.
+      def self.from_hash(data, options = {})
+        type = data["_type"] || data[:_type]
+        klass_name = IEC_TYPE_MAP[type]
+        if klass_name
+          klass = Object.const_get(klass_name)
+          return klass.from_hash(data, options) unless klass == self
+        end
+        super
       end
     end
   end

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

@@ -1,6 +1,4 @@
-require_relative "../supplement_identifier"
 # frozen_string_literal: true
-require_relative "../../components/typed_stage"
 
 module Pubid
   module Iec
@@ -86,7 +84,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :amd, title: "Amendment", short: "AMD" }
+          { key: :amd,
+            web: :amendment, title: "Amendment", short: "AMD" }
         end
       end
     end