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

data/lib/pubid/iso/identifier.rb

@@ -3,17 +3,66 @@
 module Pubid
   module Iso
     class Identifier < ::Pubid::Identifier
-      # Override base types with ISO-specific ones
-      attribute :publisher, ::Pubid::Iso::Components::Publisher
+      # Override base types with ISO-specific ones.
+      # Defaults to the type's implied publisher (ISO for most; IWA has none),
+      # so an omitted publisher key reconstructs correctly on from_hash.
+      attribute :publisher, ::Pubid::Iso::Components::Publisher,
+                default: -> { self.class.default_publisher }
       attribute :copublishers, ::Pubid::Iso::Components::Publisher,
                 collection: true
+
+      # The publisher implied when none is serialized. ISO for most types;
+      # publisher-less types (IWA) override this to nil.
+      def self.default_publisher
+        ::Pubid::Iso::Components::Publisher.new
+      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 with no stages (e.g. TC documents).
+      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 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
+
+      # Return a copy with the lifecycle stage set from an ISO harmonized stage
+      # code (e.g. "90.92"). typed_stage is the single source of truth, so this
+      # is all that is needed to surface the stage in #to_s and #to_urn. Returns
+      # an unchanged copy if the code is not recognised.
+      def with_harmonized_stage(harmonized_code)
+        ts = Pubid::Iso.locate_stage_by_harmonized_code(harmonized_code)
+        ts ? dup.tap { |id| id.typed_stage = ts } : dup
+      end
+
       attribute :number, ::Pubid::Iso::Components::Code
       attribute :part, ::Pubid::Iso::Components::Code
       attribute :subpart, ::Pubid::Iso::Components::Code
 
       # Polymorphic type map for lutaml::Model key_value serialization
       # Maps polymorphic_name → class name for deserialization
-      # Validated by spec to stay in sync with Scheme.identifiers
+      # Validated by spec to stay in sync with identifier_types
       ISO_TYPE_MAP = {
         "pubid:iso:international-standard" => "Pubid::Iso::Identifiers::InternationalStandard",
         "pubid:iso:international-standardized-profile" => "Pubid::Iso::Identifiers::InternationalStandardizedProfile",
@@ -33,298 +82,215 @@ module Pubid
         "pubid:iso:data" => "Pubid::Iso::Identifiers::Data",
         "pubid:iso:tc-document" => "Pubid::Iso::Identifiers::TcDocument",
         "pubid:iso:technology-trends-assessments" => "Pubid::Iso::Identifiers::TechnologyTrendsAssessments",
+        "pubid:iso:bundled-identifier" => "Pubid::Iso::BundledIdentifier",
       }.freeze
 
-      # Build type map from Scheme.identifiers for validation
+      # Build type map from Pubid::Iso.identifier_types for validation
       def self.build_type_map
-        Scheme.identifiers.to_h do |klass|
+        Pubid::Iso.identifier_types.to_h do |klass|
           [klass.polymorphic_name, klass.name]
         end
       end
 
+      # The base Pubid::Identifier no longer auto-maps attributes, so each
+      # flavor's top class must declare its own key_value mapping. Subclasses
+      # merge their own blocks on top of this one (e.g. SupplementIdentifier
+      # adds base_identifier; Directives adds subgroup), so list every base
+      # attribute ISO serializes here once.
       key_value do
         map "_type", to: :_type, polymorphic_map: ISO_TYPE_MAP
+        # Code components serialize as their plain string value, not {value,number}.
+        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 }
+        # date serialized flat as year/month/day, nils omitted.
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "month", with: { to: :month_to_kv, from: :month_from_kv }
+        map "day", with: { to: :day_to_kv, from: :day_from_kv }
+        map "edition", to: :edition
+        map "languages", to: :languages
+        # publisher emitted only when the primary isn't the type 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 }
+        map "locality", to: :locality
+        # `type` and generic `stage` are fully derived from `typed_stage`
+        # (builder sets them via to_type/to_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
 
-      def self.parse(string, format: :auto)
-        format = Pubid::FormatDetector.detect(string) if format == :auto
+      def all_parts_to_kv(model, doc)
+        return unless model.all_parts
 
-        case format
-        when :urn
-          Pubid::Iso::UrnParser.parse(string)
-        when :mr_string
-          Pubid::Parsers::MrString.parse(string)
-        else
-          parsed = Pubid::Iso::Parser.new.parse(string)
-          if parsed.nil? || parsed.empty?
-            raise Pubid::Iso::Parser::ParseError,
-                  "Invalid identifier format"
-          end
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("all_parts", true),
+        )
+      end
 
-          Pubid::Iso::Builder.new(Pubid::Iso::Scheme).build(parsed)
-        end
+      def all_parts_from_kv(model, value)
+        model.all_parts = value
       end
 
-      # Factory mirroring pubid 1.x's `Pubid::Iso::Identifier.create` API.
-      #
-      # Accepts 1.x-style primitive kwargs and dispatches to the correct
-      # 2.x `Identifiers::*` subclass via {Pubid::Iso::Scheme}. Coerces
-      # primitives into ISO-specific Component objects.
-      #
-      # Dispatch rules:
-      #   * `type:` (e.g. `:tr`, `:amd`)        → lookup via Scheme
-      #   * else `stage:` (e.g. `"DIS"`, `"AMD"`) → lookup via Scheme
-      #   * else                                → InternationalStandard
-      #
-      # @param type    [Symbol, String, nil] type key (`:is`, `:tr`, `:amd`, …)
-      # @param stage   [String, Symbol, nil] typed-stage abbreviation
-      # @param opts    [Hash] remaining attribute primitives:
-      #   :publisher (String), :number, :part, :subpart, :year, :edition,
-      #   :language
-      # @return [Pubid::Iso::Identifier]
-      def self.create(type: nil, stage: nil, base: nil, **opts)
-        # A bundled directive (e.g. "ISO/IEC DIR 1 + IEC SUP") is stored by the
-        # 1.x index as the base document's fields plus a nested joint_document
-        # (or a supplements array). The 2.x model is a separate
-        # BundledIdentifier; build that so .create round-trips parse.
-        if opts[:joint_document] || opts[:supplements]
-          return build_bundled(type: type, stage: stage, base: base, **opts)
-        end
+      # Serialize typed_stage as just its unique code (e.g. "is", "dis",
+      # "committee_draft_amd"). type/stage are recomputed from it on load.
+      def stage_to_kv(model, doc)
+        ts = model.typed_stage
+        return unless ts&.code
+        # Omit the published default (recomputed from the class on load).
+        return if ts.stage_code.to_s == "published"
 
-        klass = resolve_create_class(type: type, stage: stage, base: base)
-        attrs = coerce_create_attrs(opts)
-        ts = resolve_create_typed_stage(klass, stage)
-        if ts
-          # dup the (shared) TYPED_STAGES element before tweaking, and set
-          # original_abbr to the canonical abbr so rendering matches a
-          # parsed identifier (parse records the spelled abbr, e.g. "Amd"
-          # not the upcased short_abbr "AMD").
-          ts = ts.dup
-          ts.original_abbr ||= Array(ts.abbr).first&.to_s
-          attrs[:typed_stage] = ts
-          # Parse fills `type` and `stage` Components derived from
-          # typed_stage; mirror that here so .create round-trips through
-          # Pubid::Identifier#== with a parsed identifier.
-          attrs[:type] ||= ::Pubid::Components::Type.new(
-            name:      ts.name,
-            abbr:      Array(ts.abbr).first.to_s,
-            type_code: ts.type_code&.to_s,
-          )
-          attrs[:stage] ||= ::Pubid::Components::Stage.new(
-            name:              ts.name,
-            stage_code:        ts.stage_code&.to_s,
-            abbr:              Array(ts.abbr).first.to_s,
-            harmonized_stages: Array(ts.harmonized_stages),
-          )
-        end
-        # Build the base_identifier whenever a `base:` is supplied, regardless
-        # of whether the resolved class is registered as a supplement (e.g.
-        # DirectivesSupplement holds a base but is not in
-        # Scheme#supplement_identifiers). Only classes that *require* a base
-        # and were given none raise.
-        if base
-          attrs[:base_identifier] = build_base_identifier(base)
-        elsif supplement_klass?(klass)
-          raise ArgumentError, "#{klass} requires a base: identifier"
-        end
-        # For a DirectivesSupplement the top-level `publisher:` names the
-        # supplement's own publisher ("… ISO SUP"), not the document's — the
-        # document publisher lives on the base. Mirror parse, which records it
-        # as `supplement_publisher`.
-        if klass <= Identifiers::DirectivesSupplement && attrs.key?(:publisher)
-          attrs[:supplement_publisher] = attrs.delete(:publisher)
-          attrs.delete(:copublishers)
-        end
-        klass.new(**attrs)
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("stage", ts.code.to_s),
+        )
       end
 
-      # Build a BundledIdentifier (base document + supplements) from the 1.x
-      # index shape: the top-level fields are the base document, and each
-      # joint_document/supplements entry is a joined supplement.
-      def self.build_bundled(type:, stage:, base:, **opts)
-        raw = opts.delete(:joint_document) || opts.delete(:supplements)
-        entries = raw.is_a?(Array) ? raw : [raw]
-        base_document = create(type: type, stage: stage, base: base, **opts)
-        supplements = entries.map { |j| build_joint_supplement(j) }
-        BundledIdentifier.new(base_document: base_document,
-                              supplements: supplements)
+      # Resolve the typed-stage code back to the full TypedStage within this
+      # identifier's class, then derive type/stage from it.
+      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::Iso::Scheme.locate_typed_stage_by_code(value)
+        return unless ts
+
+        # The renderer prefers `original_abbr` (the parsed surface form); without
+        # it the supplement renderer falls back to `short_abbr` (e.g. "AMD").
+        # Resolving from a code has no surface form, so render the canonical
+        # abbreviation (`abbr.first`, e.g. "Amd").
+        ts = ts.dup
+        ts.original_abbr = ts.canonical_abbreviation
+        model.typed_stage = ts
       end
 
-      # Map a 1.x joint_document hash to a 2.x supplement matching parse. The
-      # index nests the supplement's publisher under joint_document.base.publisher
-      # (e.g. "IEC" for "+ IEC SUP"), while parse records it as the supplement's
-      # own publisher; move it and drop the nested base + empty top publisher.
-      def self.build_joint_supplement(joint)
-        j = joint.transform_keys(&:to_sym)
-        b = (j[:base] || {}).transform_keys(&:to_sym)
-        publisher = b[:publisher].to_s.empty? ? j[:publisher] : b[:publisher]
-        create(
-          type: j[:type],
-          publisher: publisher,
-          copublisher: b[:copublisher] || j[:copublisher],
-          number: (j[:number] unless j[:number].to_s.empty?),
-          year: j[:year],
-        )
+      # --- 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 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
 
-      # Build the base_identifier for a supplement from either an already
-      # constructed identifier or a 1.x-style attribute hash (the nested
-      # `:base` entry in a structured index). Recurses so supplement-of-
-      # supplement chains (e.g. a Corrigendum to an Amendment) build cleanly.
-      def self.build_base_identifier(base)
-        return base if base.is_a?(::Pubid::Identifier)
+      def stage_iteration_from_kv(model, value)
+        model.stage_iteration = ::Pubid::Components::Iteration.new(number: value.to_s)
+      end
 
-        create(**base.transform_keys(&:to_sym))
+      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
 
-      # When `stage:` is explicit, look up the matching TypedStage via
-      # Scheme. Otherwise default to the chosen class's "published"
-      # TypedStage (so e.g. TR renders the "/TR" prefix). Returns nil if
-      # neither is available; the renderer then omits the stage prefix.
-      def self.resolve_create_typed_stage(klass, stage)
-        if stage
-          ts = locate_create_typed_stage(stage)
-          ts && retype_stage_for_class(klass, ts)
-        elsif klass.const_defined?(:TYPED_STAGES)
-          klass.const_get(:TYPED_STAGES).find do |ts|
-            ts.stage_code.to_sym == :published
-          end
-        end
+      def build_code(value)
+        ::Pubid::Iso::Components::Code.new(value: value.to_s)
       end
 
-      # Indexes store a supplement's stage as the bare review-stage abbr
-      # ("CD", "WD", "AWI") plus a separate type ("AMD"), so the global lookup
-      # resolves the stage to the IS-typed variant (cdis) rather than the
-      # amendment-typed one (committee_draft_amd). When the resolved stage's
-      # type differs from the class chosen via `type:`, re-pick the equivalent
-      # stage from the class's own TYPED_STAGES. harmonized_stages is the
-      # stable cross-type key (stage_code/abbr diverge between IS and amd:
-      # IS "WD" is :working_draft, the amendment is :wd_amd).
-      def self.retype_stage_for_class(klass, ts)
-        return ts unless klass.const_defined?(:TYPED_STAGES)
-        return ts unless klass.respond_to?(:type) && klass.type
-        return ts if ts.type_code.to_s == klass.type[:key].to_s
-
-        harmonized = Array(ts.harmonized_stages)
-        return ts if harmonized.empty?
-
-        klass.const_get(:TYPED_STAGES).find do |s|
-          (Array(s.harmonized_stages) & harmonized).any?
-        end || ts
+      # --- date serialized flat as year/month/day ---
+      def year_to_kv(model, doc) = emit_date_part(doc, "year", model.date&.year)
+      def year_from_kv(model, value) = date_for(model).year = value.to_s
+      def month_to_kv(model, doc) = emit_date_part(doc, "month", model.date&.month)
+      def month_from_kv(model, value) = date_for(model).month = value.to_s
+      def day_to_kv(model, doc) = emit_date_part(doc, "day", model.date&.day)
+      def day_from_kv(model, value) = date_for(model).day = value.to_s
+
+      def emit_date_part(doc, key, val)
+        return if val.nil? || val.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, val.to_s))
       end
 
-      # Resolve a TypedStage from a create() :stage value. The index may
-      # supply it as an abbreviation ("DIS"), a generic stage_code (:dis),
-      # or a unique per-typed-stage code (:dtr, :fdisp). Try each in turn.
-      def self.locate_create_typed_stage(stage)
-        Scheme.locate_typed_stage_by_abbr(stage.to_s) ||
-          Scheme.locate_typed_stage_by_stage_code(stage) ||
-          Scheme.locate_typed_stage_by_code(stage)
+      def date_for(model)
+        model.date ||= ::Pubid::Components::Date.new
       end
 
-      def self.resolve_create_class(type:, stage:, base: nil)
-        klass =
-          if type
-            located = locate_klass_by_type_or_short(type)
-            raise ArgumentError, "Unknown ISO type: #{type.inspect}" unless located
+      # --- publisher: primary only when non-default; copublishers as a list ---
+      def publisher_to_kv(model, doc)
+        pub = model.publisher&.publisher
+        return if pub.nil? || pub == model.class.default_publisher&.publisher
 
-            located
-          elsif stage
-            ts = locate_create_typed_stage(stage)
-            ts && Scheme.locate_identifier_klass_by_type_code(ts.type_code)
-          end
-        # A bare `base:` with no type/stage is still a supplement; fall back to
-        # the generic Supplement (which can hold a base) rather than
-        # InternationalStandard (which cannot).
-        klass ||= Identifiers::Supplement if base
-        klass || Identifiers::InternationalStandard
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("publisher", pub))
       end
 
-      # Try direct key lookup, then a case-insensitive key lookup (indexes
-      # store e.g. "DATA" but the registry key is :data), then fall back to
-      # matching the class's :short letter (e.g. type "R" → Recommendation,
-      # whose key is :rec and short is "R"). Indexes and legacy data carry
-      # either the key, an upper-cased key, or the short form.
-      def self.locate_klass_by_type_or_short(type)
-        Scheme.locate_identifier_klass_by_type_code(type) ||
-          Scheme.locate_identifier_klass_by_type_code(type.to_s.downcase) ||
-          Scheme.identifiers.detect { |k| k.type&.dig(:short)&.to_s == type.to_s }
+      def publisher_from_kv(model, value)
+        publisher_for(model).publisher = value.to_s
       end
 
-      def self.supplement_klass?(klass)
-        Array(Scheme.instance.supplement_identifiers).include?(klass)
+      def copublishers_to_kv(model, doc)
+        cp = model.publisher&.copublisher
+        return unless cp&.any?
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("copublishers", cp.map(&:to_s)),
+        )
       end
 
-      def self.coerce_create_attrs(opts)
-        out = {}
-        if (v = opts[:publisher])
-          # Mirror parse: the publisher carries its copublishers in its own
-          # copublisher list, and each copublisher is also a standalone entry
-          # in the copublishers collection. No copublisher → [] (parity with
-          # parsed plain-ISO identifiers).
-          cops = Array(opts[:copublisher]).map(&:to_s)
-          out[:publisher] = Components::Publisher.new(
-            publisher: v.to_s, copublisher: cops,
-          )
-        end
-        if opts[:copublisher]
-          out[:copublishers] = Array(opts[:copublisher]).map do |c|
-            Components::Publisher.new(publisher: c.to_s)
-          end
-        end
-        %i[number part subpart].each do |k|
-          v = opts[k]
-          out[k] = Components::Code.new(number: v.to_s) unless v.nil?
-        end
-        if (v = opts[:year])
-          out[:date] = ::Pubid::Components::Date.new(year: v.to_s)
+      def copublishers_from_kv(model, value)
+        list = Array(value).map(&:to_s)
+        return unless list.any?
+
+        # Mirror Builder#parse: copublishers live both on the primary
+        # publisher (as strings) and as the top-level `copublishers`
+        # collection of Publisher objects. `==` compares the latter, so
+        # populate both or a deserialized id never equals a parsed one.
+        publisher_for(model).copublisher = list
+        model.copublishers = list.map do |cp|
+          ::Pubid::Iso::Components::Publisher.new(publisher: cp)
         end
-        if (v = opts[:edition])
-          if v.is_a?(Hash)
-            # 1.x stored a directive org-variant ("ISO/IEC DIR 2 ISO" /
-            # "ISO/IEC DIR 1 IEC:2023") as edition: {publisher:, year:}; parse
-            # models the org as `part` and the year as `date`. Map it so create
-            # round-trips parse.
-            eh = v.transform_keys(&:to_sym)
-            out[:part] ||= Components::Code.new(number: eh[:publisher].to_s) if eh[:publisher]
-            out[:date] ||= ::Pubid::Components::Date.new(year: eh[:year].to_s) if eh[:year]
-          else
-            out[:edition] = ::Pubid::Components::Edition.new(number: v)
+      end
+
+      def publisher_for(model)
+        model.publisher ||= ::Pubid::Iso::Components::Publisher.new
+      end
+
+      def self.parse(string, format: :auto)
+        format = Pubid::FormatDetector.detect(string) if format == :auto
+
+        case format
+        when :urn
+          Pubid::Iso::UrnParser.parse(string)
+        when :mr_string
+          Pubid::Parsers::MrString.parse(string)
+        else
+          parsed = Pubid::Iso::Parser.new.parse(string)
+          if parsed.nil? || parsed.empty?
+            raise Pubid::Iso::Parser::ParseError,
+                  "Invalid identifier format"
           end
+
+          Pubid::Iso::Builder.new.build(parsed)
         end
-        if (v = opts[:language])
-          out[:languages] =
-            [::Pubid::Components::Language.new(code: v.to_s)]
-        end
-        # TcDocument committee fields: the 1.x/index shape is the flat
-        # tctype/tcnumber/… keys, but the 2.x model stores underscored Code
-        # components (mirrors the parser's builder). Without this mapping a
-        # TC document round-trips to a bare "ISO N <num>".
-        { tctype: :tc_type, tcnumber: :tc_number,
-          sctype: :sc_type, scnumber: :sc_number,
-          wgtype: :wg_type, wgnumber: :wg_number }.each do |src, dest|
-          v = opts[src]
-          out[dest] = Components::Code.new(number: v.to_s) unless v.nil?
-        end
-        # Directives subgroup (e.g. "ISO/IEC JTC 1 DIR"): the 1.x/index shape
-        # is dirtype: "JTC", jtc_dir: "DIR", number: "1"; the 2.x model folds
-        # the subgroup into a single `subgroup` Code ("JTC 1") with no
-        # directive number, mirroring parse. Without this, .create drops the
-        # subgroup and collapses the id into a plain "DIR 1".
-        if opts[:dirtype]
-          out[:subgroup] = Components::Code.new(
-            number: [opts[:dirtype], opts[:number]].compact.join(" "),
-          )
-          out.delete(:number)
+      end
+
+      # lutaml's polymorphic key_value mapping reads `_type` only to validate;
+      # it does not re-instantiate the concrete subclass on deserialization. So
+      # `Identifier.from_hash(corrigendum_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 JIS.
+      def self.from_hash(data, options = {})
+        type = data["_type"] || data[:_type]
+        klass_name = ISO_TYPE_MAP[type]
+        if klass_name
+          klass = Object.const_get(klass_name)
+          return klass.from_hash(data, options) unless klass == self
         end
-        # TODO(create-shim): 1.x also accepted iteration, amendments,
-        # corrigendums, addendum, month, dir. Add as relaton call sites
-        # require them.
-        out
+        super
       end
-      private_class_method :resolve_create_class, :supplement_klass?,
-                           :resolve_create_typed_stage, :coerce_create_attrs,
-                           :build_bundled, :build_joint_supplement
     end
   end
 end

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

@@ -4,7 +4,6 @@ module Pubid
   module Iso
     module Identifiers
       class Addendum < SupplementIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         # Override URN supplement type to use generic "sup" instead of "add"
         # This matches the ISO URN specification where addendums use "sup"
@@ -65,9 +64,11 @@ module Pubid
           ),
           ::Pubid::Components::TypedStage.new(
             code: :dad,
-            abbr: ["DAD", "DAdd", "D ADD", "Dad"],
+            abbr: ["DAD", "DAdd", "D ADD", "Dad", "DIS Add"],
             short_abbr: "DAD",
-            long_abbr: "DAdd",
+            # "DAdd" stays in `abbr` so it still parses, but render the canonical
+            # "DAD" (pubid v1 legacy_abbr parity). No long_abbr → no long render.
+            long_abbr: nil,
             type_code: :add,
             stage_code: :dad,
             name: "Draft Addendum",
@@ -75,9 +76,10 @@ module Pubid
           ),
           ::Pubid::Components::TypedStage.new(
             code: :fdad,
-            abbr: ["FDAD", "FDAdd", "FD ADD", "FDad"],
+            abbr: ["FDAD", "FDAdd", "FD ADD", "FDad", "FDIS Add"],
             short_abbr: "FDAD",
-            long_abbr: "FDAdd",
+            # See :dad — parse "FDAdd", render canonical "FDAD" (v1 parity).
+            long_abbr: nil,
             type_code: :add,
             stage_code: :fdad,
             name: "Final Draft Addendum",
@@ -96,7 +98,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :add, title: "Addendum", short: "ADD" }
+          { key: :add,
+            web: :addendum, title: "Addendum", short: "ADD" }
         end
       end
     end

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

@@ -4,7 +4,6 @@ module Pubid
   module Iso
     module Identifiers
       class Amendment < SupplementIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -71,7 +70,10 @@ module Pubid
             code: :damd,
             abbr: ["DAM", "DAmd"],
             short_abbr: "DAM",
-            long_abbr: "DAmd",
+            # "DAmd" stays in `abbr` so it still parses, but render the canonical
+            # "DAM" (matches pubid v1's legacy_abbr semantics: parse the long
+            # spelling, emit the short one). No long_abbr → no long rendering.
+            long_abbr: nil,
             type_code: :amd,
             stage_code: :damd,
             name: "Draft Amendment",
@@ -81,7 +83,8 @@ module Pubid
             code: :fdamd,
             abbr: ["FDAM", "FDAmd"],
             short_abbr: "FDAM",
-            long_abbr: "FDAmd",
+            # See :damd — parse "FDAmd", render canonical "FDAM" (v1 parity).
+            long_abbr: nil,
             type_code: :amd,
             stage_code: :fdamd,
             name: "Final Draft Amendment",
@@ -120,7 +123,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :amd, title: "Amendment", short: "AMD" }
+          { key: :amd,
+            web: :amendment, title: "Amendment", short: "AMD" }
         end
       end
     end