pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

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

@@ -1,58 +1,34 @@
-require "lutaml/model"
-require_relative "../../components/code"
 # frozen_string_literal: true
 
 module Pubid
   module Iec
     module Components
+      # 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
-        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
-
         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

@@ -1,5 +1,4 @@
 require "lutaml/model"
-require_relative "../../components/publisher"
 # frozen_string_literal: true
 
 module Pubid

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,256 +1,294 @@
-require_relative "../identifier"
 # frozen_string_literal: true
-require_relative "../components/typed_stage"
-require_relative "../components/factory"
 
 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
-      # Long-tail document types that `create` may build but which are not in
-      # Scheme.identifiers (the parse/build candidate set). Loaded lazily (not
-      # at require time) to avoid a circular load with identifiers/base.rb.
-      EXTRA_CREATE_KLASS_FILES = %w[
-        conformity_assessment technology_report white_paper
-        societal_technology_trend_report systems_reference_document
-        interpretation_sheet
-      ].freeze
-      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
+      # 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
 
-        # Apply legacy update_codes normalization first, before any other preprocessing
-        normalized = Core::UpdateCodes.apply(string, :iec)
-        parsed = Pubid::Iec::Parser.new.parse(normalized)
-        if parsed.nil? || parsed.empty?
-          raise Pubid::Iec::Parser::ParseError,
-                "Invalid identifier format"
-        end
+      # The publisher implied when none is serialized (IEC for every type).
+      def self.default_publisher
+        ::Pubid::Iec::Components::Publisher.new(body: "IEC")
+      end
 
-        Pubid::Iec::Builder.new(Pubid::Iec::Scheme).build(parsed)
+      # 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
 
-      # Factory mirroring pubid 1.x's `Pubid::Iec::Identifier.create` API.
-      # See {Pubid::Iso::Identifier.create} for the shared design. Builds the
-      # IEC `Components::*` subclasses (not the base ones) and populates
-      # type/stage from the resolved TypedStage, so that a created identifier
-      # round-trips `==` against the same identifier produced by `parse`.
-      def self.create(type: nil, stage: nil, **opts)
-        # A VAP suffix (CSV/RLV/…) is the outermost wrapper around the base
-        # document (which may itself be amended); rebuild it first.
-        if (vap = opts.delete(:vap))
-          base = create(type: type, stage: stage, **opts)
-          return Identifiers::VapIdentifier.new(
-            base_identifier: base,
-            vap_suffix: Components::VapSuffix.new(code: Array(vap).first.to_s),
-          )
-        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
 
-        # Structured index rows carry amendments/corrigendums as a flat list
-        # alongside the base document's keys; rebuild the supplement wrapping
-        # the recursively-created base, mirroring what parse produces.
-        if (supp = extract_supplement(opts))
-          return build_supplement(supp, type: type, stage: stage, opts: opts)
-        end
+      def stage
+        typed_stage&.to_stage
+      end
 
-        # A nested base: holds the base document of a supplement whose own
-        # number/year sit at the top level (e.g. an Interpretation Sheet).
-        if (base_hash = opts.delete(:base))
-          return build_based_supplement(type: type, base_hash: base_hash,
-                                        opts: opts)
-        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
 
-        klass = resolve_create_class(type: type, stage: stage)
-        attrs = coerce_create_attrs(opts)
-        ts = resolve_create_typed_stage(klass, stage)
-        if ts
-          attrs[:typed_stage] = ts
-          # Parse derives `type` and `stage` from the TypedStage (see
-          # Builder#cast for :type_with_stage); mirror that here.
-          attrs[:type] ||= ts.to_type
-          attrs[:stage] ||= ts.to_stage
-        end
-        klass.new(**attrs)
+      # 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
 
-      # Pop a supplement spec off the flat opts hash, if present. Returns
-      # { klass:, entry: } or nil. Amendments take precedence over
-      # corrigendums for the (rare) consolidated rows that carry both.
-      def self.extract_supplement(opts)
-        if (amds = opts.delete(:amendments))
-          { klass: Identifiers::Amendment, entry: Array(amds).first }
-        elsif (cors = opts.delete(:corrigendums))
-          { klass: Identifiers::Corrigendum, entry: Array(cors).first }
-        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
 
-      # Build an Amendment/Corrigendum from { number:, year: } wrapping a base
-      # identifier created from the remaining opts (which may themselves carry
-      # a type, e.g. an amendment to a TR).
-      def self.build_supplement(supp, type:, stage:, opts:)
-        base = create(type: type, stage: stage, **opts)
-        klass = supp[:klass]
-        entry = supp[:entry] || {}
-        ts = klass::TYPED_STAGES.find { |t| t.stage_code.to_sym == :published }
-        attrs = { base_identifier: base, typed_stage: ts,
-                  type: ts.to_type, stage: ts.to_stage }
-        if (n = entry[:number])
-          attrs[:number] = Components::Code.new(number: n.to_s)
-        end
-        if (y = entry[:year])
-          attrs[:date] = ::Pubid::Components::Date.new(year: y.to_s)
-        end
-        klass.new(**attrs)
+      # --- 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
 
-      # Build a supplement whose base document is carried in a nested base:
-      # hash (e.g. type: "ISH"); the supplement's own number/year are the
-      # remaining top-level keys.
-      def self.build_based_supplement(type:, base_hash:, opts:)
-        klass = (type && locate_klass_by_type_or_short(type)) ||
-                Identifiers::InternationalStandard
-        base = create(**base_hash.transform_keys(&:to_sym))
-        attrs = coerce_create_attrs(opts)
-                .slice(:number, :part, :subpart, :date, :publisher, :copublishers)
-        attrs[:base_identifier] = base
-        if klass.const_defined?(:TYPED_STAGES) &&
-            (ts = klass::TYPED_STAGES.find { |t| t.stage_code.to_sym == :published })
-          attrs[:typed_stage] = ts
-          attrs[:type] ||= ts.to_type
-          attrs[:stage] ||= ts.to_stage
-        end
-        klass.new(**attrs)
+      def build_code(value)
+        return if value.nil? || value.to_s.empty?
+
+        ::Pubid::Iec::Components::Code.new(value: value.to_s)
       end
 
-      # Coerce a 1.x-style attribute hash into IEC Component instances,
-      # matching what the parser/builder produces. Unknown keys are dropped.
-      def self.coerce_create_attrs(opts)
-        out = {}
-        if (v = opts[:publisher])
-          out[:publisher] = Components::Publisher.new(body: v.to_s)
-        end
-        if (copubs = opts[:copublishers] || opts[:copublisher])
-          out[:copublishers] =
-            Array(copubs).map { |c| Components::Publisher.new(body: c.to_s) }
-        end
-        if (v = opts[:number])
-          out[:number] = Components::Code.new(number: v.to_s)
-        end
-        # Indexes fold the subpart into a single "2-4" part string; parse
-        # keeps part and subpart separate, so split to match.
-        part, subpart = split_part(opts[:part], opts[:subpart])
-        out[:part] = Components::Code.new(number: part.to_s) unless part.nil?
-        out[:subpart] = Components::Code.new(number: subpart.to_s) unless subpart.nil?
-        if (v = opts[:year])
-          out[:date] = ::Pubid::Components::Date.new(year: v.to_s)
-        end
-        if (v = opts[:edition])
-          out[:edition] = ::Pubid::Components::Edition.new(number: v)
-        end
-        if (v = opts[:language])
-          out[:languages] = [::Pubid::Components::Language.new(code: v.to_s)]
-        end
-        out[:database] = true if opts[:database]
-        out
+      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
 
-      # Split a folded "2-4" part into [part, subpart], matching parse. A part
-      # without a dash (or an explicit subpart already supplied) is untouched.
-      def self.split_part(part, subpart)
-        return [nil, subpart] if part.nil?
-        if subpart.nil? && part.to_s.include?("-")
-          part.to_s.split("-", 2)
-        else
-          [part, subpart]
-        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
 
-      def self.resolve_create_class(type:, stage:)
-        if type && supplement_type?(type)
-          # Supplements are built from amendments:/corrigendums: data (which
-          # carry the supplement number/year); an explicit supplement `type:`
-          # alone has no base to wrap.
-          raise ArgumentError,
-                "#{type} requires a base_identifier; pass amendments:/" \
-                "corrigendums: instead of type:"
-        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?
 
-        klass =
-          if type
-            locate_klass_by_type_or_short(type)
-          elsif stage
-            ts = safe_locate_typed_stage(stage)
-            ts && locate_klass_by_type_or_short(ts.type_code)
-          end
-        klass || Identifiers::InternationalStandard
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("year", y.to_s))
       end
 
-      # True when `type` names a supplement identifier (Amendment/Corrigendum/
-      # Fragment) by key, downcased key, or short abbreviation.
-      def self.supplement_type?(type)
-        t = type.to_s
-        Scheme.supplement_identifiers.any? do |k|
-          k.type[:key].to_s == t || k.type[:key].to_s == t.downcase ||
-            Array(k.type[:short]).map(&:to_s).include?(t)
-        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
 
-      # Structured indexes store `type:` as the registry key (:tr), an
-      # upper-cased abbreviation ("TR"), or a title ("Technology Report").
-      # Try each spelling, across every IEC identifier class (the create
-      # candidate set is wider than Scheme.identifiers).
-      def self.locate_klass_by_type_or_short(type)
-        t = type.to_s
-        all_create_klasses.detect { |k| k.type[:key].to_s == t } ||
-          all_create_klasses.detect { |k| k.type[:key].to_s == t.downcase } ||
-          all_create_klasses.detect { |k| Array(k.type[:short]).map(&:to_s).include?(t) } ||
-          all_create_klasses.detect { |k| k.type[:title].to_s == t }
+      # --- 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
 
-      # All IEC identifier classes that `create` may build, including the
-      # long-tail document types absent from Scheme.identifiers. Memoized;
-      # the extra classes are required here (not at load time) to dodge the
-      # circular require with identifiers/base.rb.
-      def self.all_create_klasses
-        @all_create_klasses ||= begin
-          extra = EXTRA_CREATE_KLASS_FILES.map do |f|
-            require_relative "identifiers/#{f}"
-            Identifiers.const_get(camelize_klass_file(f))
-          end
-          Scheme.identifiers + extra
+      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
 
-      def self.camelize_klass_file(file)
-        file.split("_").map(&:capitalize).join
+      # --- 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
 
-      # IEC Scheme raises ArgumentError on miss instead of returning nil;
-      # wrap so the same control flow works as in the ISO factory.
-      def self.safe_locate_typed_stage(abbr)
-        Scheme.locate_typed_stage_by_abbr(abbr.to_s)
-      rescue ArgumentError
-        nil
+      # 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)
+        if parsed.nil? || parsed.empty?
+          raise Pubid::Iec::Parser::ParseError,
+                "Invalid identifier format"
+        end
+
+        Pubid::Iec::Builder.new.build(parsed)
       end
 
-      def self.resolve_create_typed_stage(klass, stage)
-        if stage
-          safe_locate_typed_stage(stage)
-        elsif klass.const_defined?(:TYPED_STAGES)
-          klass.const_get(:TYPED_STAGES).find do |ts|
-            ts.stage_code.to_sym == :published
-          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
-      private_class_method :resolve_create_class,
-                           :safe_locate_typed_stage,
-                           :resolve_create_typed_stage, :coerce_create_attrs,
-                           :extract_supplement, :build_supplement,
-                           :build_based_supplement,
-                           :locate_klass_by_type_or_short, :all_create_klasses,
-                           :camelize_klass_file, :supplement_type?,
-                           :split_part
     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