pubid 2.0.0.pre.alpha.1 → 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,17 +82,180 @@ 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 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. "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"
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("stage", ts.code.to_s),
+        )
+      end
+
+      # 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
+
+      # --- 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
+
+      def stage_iteration_from_kv(model, value)
+        model.stage_iteration = ::Pubid::Components::Iteration.new(number: value.to_s)
+      end
+
+      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)
+        ::Pubid::Iso::Components::Code.new(value: value.to_s)
+      end
+
+      # --- 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
+
+      def date_for(model)
+        model.date ||= ::Pubid::Components::Date.new
+      end
+
+      # --- 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
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("publisher", pub))
+      end
+
+      def publisher_from_kv(model, value)
+        publisher_for(model).publisher = value.to_s
+      end
+
+      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 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
+      end
+
+      def publisher_for(model)
+        model.publisher ||= ::Pubid::Iso::Components::Publisher.new
       end
 
       def self.parse(string, format: :auto)
@@ -61,8 +273,23 @@ module Pubid
                   "Invalid identifier format"
           end
 
-          Pubid::Iso::Builder.new(Pubid::Iso::Scheme).build(parsed)
+          Pubid::Iso::Builder.new.build(parsed)
+        end
+      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
+        super
       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

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

@@ -4,7 +4,6 @@ module Pubid
   module Iso
     module Identifiers
       class Corrigendum < SupplementIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -59,7 +58,7 @@ module Pubid
           ),
           ::Pubid::Components::TypedStage.new(
             code: :dcor,
-            abbr: ["DCor", "DCOR"],
+            abbr: ["DCor", "DCOR", "DIS Cor"],
             short_abbr: "DCOR",
             long_abbr: "DCor",
             type_code: :cor,
@@ -69,7 +68,7 @@ module Pubid
           ),
           ::Pubid::Components::TypedStage.new(
             code: :fdcor,
-            abbr: ["FDCor", "FDCOR", "FCOR"],
+            abbr: ["FDCor", "FDCOR", "FCOR", "FDIS Cor"],
             short_abbr: "FDCOR",
             long_abbr: "FDCor",
             type_code: :cor,
@@ -100,7 +99,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :cor, title: "Corrigendum", short: "COR" }
+          { key: :cor,
+            web: :corrigendum, title: "Corrigendum", short: "COR" }
         end
       end
     end

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

@@ -5,7 +5,6 @@ module Pubid
     module Identifiers
       # Data Identifier
       class Data < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(

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

@@ -4,9 +4,14 @@ module Pubid
   module Iso
     module Identifiers
       class Directives < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
         attribute :subgroup, ::Pubid::Components::Code
 
+        # Merges with Identifier's block (base attributes); only adds the
+        # Directives-specific subgroup so it survives to_hash/from_hash.
+        key_value do
+          map "subgroup", to: :subgroup
+        end
+
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
             code: :pubguide,
@@ -22,7 +27,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :dir, title: "Directives", short: "DIR" }
+          { key: :dir,
+            web: :directives, title: "Directives", short: "DIR" }
         end
 
         def to_s(**opts)

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

@@ -4,9 +4,35 @@ module Pubid
   module Iso
     module Identifiers
       class DirectivesSupplement < SupplementIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
         attribute :supplement_publisher, ::Pubid::Components::Publisher
 
+        # supplement_publisher (e.g. "IEC" in "ISO/IEC DIR 1 IEC SUP") is needed
+        # by to_s/to_urn; serialize its body under "publisher" (the supplement's
+        # own publisher; the base's publisher lives in the nested base). This
+        # overrides the inherited publisher map, whose delegated value is nil or
+        # the omitted ISO default here.
+        key_value do
+          map "publisher",
+              with: { to: :supplement_publisher_to_kv, from: :supplement_publisher_from_kv }
+        end
+
+        def supplement_publisher_to_kv(model, doc)
+          body = model.supplement_publisher&.body
+          return if body.nil? || body.to_s.empty?
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new("publisher", body.to_s),
+          )
+        end
+
+        def supplement_publisher_from_kv(model, value)
+          model.supplement_publisher = ::Pubid::Components::Publisher.new(body: value.to_s)
+        end
+
+        # copublishers here is the base's (delegated), redundant with the nested
+        # base; don't duplicate it at the supplement level.
+        def copublishers_to_kv(_model, _doc); end
+
         # Delegate base identifier attributes for easier access
         def copublishers
           base_identifier&.copublishers
@@ -28,7 +54,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :"dir-sup", title: "Directives Supplement", short: "SUP" }
+          { key: :"dir-sup",
+            web: :directives_supplement, title: "Directives Supplement", short: "SUP" }
         end
 
         # def render_directives_supplement_identifier(identifier)
@@ -47,10 +74,10 @@ format: nil, stage_format_long: nil, with_date: nil)
             [
               base_identifier.to_s(lang: lang, lang_single: lang_single,
                                    with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date),
-              " #{supplement_publisher.body}",
+              " #{supplement_publisher.render}",
               " SUP", # Always render as "SUP" even though typed_stage.abbreviation is "DIR SUP"
-              (date ? ":#{date.year}" : ""),
-              (edition ? " Edition #{edition.number.value}" : ""),
+              (date ? ":#{date.render}" : ""),
+              (edition ? " Edition #{edition.value}" : ""),
             ].join
           else
             # Simplified rendering for bundled identifiers (just the supplement part)
@@ -63,13 +90,13 @@ format: nil, stage_format_long: nil, with_date: nil)
 format: nil, stage_format_long: nil, with_date: nil)
           date_str = if date
                        month_part = date.month ? "-#{date.month}" : ""
-                       ":#{date.year}#{month_part}"
+                       ":#{date.render}#{month_part}"
                      else
                        ""
                      end
 
           [
-            supplement_publisher.body,
+            supplement_publisher.render,
             " SUP",
             date_str,
           ].join
@@ -78,13 +105,15 @@ format: nil, stage_format_long: nil, with_date: nil)
         # DirectivesSupplement use urn:iso:doc scheme (not urn:iso:std)
         # Format: urn:iso:doc:{base_urn_parts}:jtc:X:sup[:{year}][:{edition}]
         def to_urn
+          urn_ctx = Rendering::RenderingContext.urn
+
           # If this is a standalone supplement (no base_identifier), build URN directly
           unless base_identifier
             parts = ["urn", "iso", "doc"]
-            parts << supplement_publisher.body.downcase if supplement_publisher
+            parts << supplement_publisher.render(context: urn_ctx) if supplement_publisher
             parts << "sup"
-            parts << date.year.to_s if date
-            parts << "ed-#{edition.number}" if edition&.number
+            parts << date.render(context: urn_ctx) if date
+            parts << edition.render(context: urn_ctx) if edition&.number
             return parts.join(":")
           end
 
@@ -94,7 +123,7 @@ format: nil, stage_format_long: nil, with_date: nil)
           # Handle JTC pattern specially
           if supplement_publisher&.body&.match?(/^JTC\s+(\d+)$/i)
             # Extract JTC number: "JTC 1" -> ["jtc", "1"]
-            jtc_parts = supplement_publisher.body.downcase.split
+            jtc_parts = supplement_publisher.render(context: urn_ctx).split
             # Insert JTC parts before "sup"
             parts = base_urn.split(":")
             parts.concat(jtc_parts) # Add "jtc" and "1"
@@ -102,14 +131,14 @@ format: nil, stage_format_long: nil, with_date: nil)
           else
             # Normal supplement
             parts = [base_urn, "sup"]
-            parts << supplement_publisher.body.downcase if supplement_publisher
+            parts << supplement_publisher.render(context: urn_ctx) if supplement_publisher
           end
 
           # Year (if present)
-          parts << date.year.to_s if date
+          parts << date.render(context: urn_ctx) if date
 
           # Edition (if present)
-          parts << "ed-#{edition.number}" if edition&.number
+          parts << edition.render(context: urn_ctx) if edition&.number
 
           parts.join(":")
         end

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

@@ -4,7 +4,6 @@ module Pubid
   module Iso
     module Identifiers
       class Extract < SupplementIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -18,7 +17,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :ext, title: "Extract", short: "Ext" }
+          { key: :ext,
+            web: :extract, title: "Extract", short: "Ext" }
         end
 
         # def self.get_renderer_class

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

@@ -4,7 +4,6 @@ module Pubid
   module Iso
     module Identifiers
       class Guide < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(

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

@@ -8,7 +8,6 @@ module Pubid
         include IdentifierMetadata
 
         # Note: type attribute uses shared Components::Type from Pubid namespace
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -142,7 +141,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :is, title: "International Standard", short: nil }
+          { key: :is,
+            web: :international_standard, title: "International Standard", short: nil }
         end
 
         # Define machine-readable metadata
@@ -164,5 +164,5 @@ module Pubid
   end
 end
 
-# NOTE: Identifiers are now registered in the ISO Scheme class
-# The global registry has been removed in favor of per-flavor Schemes
+# NOTE: Identifiers are now registered in the ISO flavor module
+# The global registry has been removed in favor of self-describing types

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

@@ -5,7 +5,6 @@ module Pubid
     module Identifiers
       # International Standardized Profile Identifier
       class InternationalStandardizedProfile < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -52,7 +51,7 @@ module Pubid
             code: :disp,
             stage_code: :disp,
             type_code: :isp,
-            abbr: ["DISP"],
+            abbr: ["DISP", "DIS ISP"],
             name: "Draft International Standardized Profile",
             harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
           ),
@@ -61,7 +60,7 @@ module Pubid
             code: :fdisp,
             stage_code: :fdis,
             type_code: :isp,
-            abbr: ["FDISP"],
+            abbr: ["FDISP", "FDIS ISP"],
             name: "Final Draft International Standardized Profile",
             harmonized_stages: %w[50.00 50.20 50.60 50.92],
           ),
@@ -85,7 +84,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :isp, title: "International Standardized Profile",
+          { key: :isp,
+            web: :international_standardized_profile, title: "International Standardized Profile",
             short: "ISP" }
         end
       end

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

@@ -4,12 +4,17 @@ module Pubid
   module Iso
     module Identifiers
       class InternationalWorkshopAgreement < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
+
+        # IWA identifiers have no publisher prefix (rendered "IWA 1", not
+        # "ISO IWA 1"), so there is no implied publisher to default on load.
+        def self.default_publisher
+          nil
+        end
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
-            code: :npiwa,
-            stage_code: :np,
+            code: :pwiiwa,
+            stage_code: :pwi,
             type_code: :iwa,
             abbr: ["PWI IWA"],
             name: "Proposed Work Item for International Workshop Agreement",
@@ -75,7 +80,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :iwa, title: "International Workshop Agreement", short: "IWA" }
+          { key: :iwa,
+            web: :international_workshop_agreement, title: "International Workshop Agreement", short: "IWA" }
         end
 
         def to_s(**opts)