pubid 2.0.26 → 2.0.28

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

@@ -0,0 +1,27 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # The synthesized Corrigendum wrapper (PFS supplements
+      # declaration, issue #121 feature 3): the kind face
+      # "AC" is the run's dispatch token and the
+      # printed notation's face.
+      class Corrigendum < Supplement
+        FACE = "AC".freeze
+
+        def self.face
+          FACE
+        end
+
+        def self.polymorphic_name
+          "pubid:cencenelec:corrigendum"
+        end
+                            
+                            # The MR slug's supplement suffix: the shared MrString
+                            # recurses into base and appends this.
+                            def mr_supplement_suffix
+                              mr_join_segments("cor", number, supplement_date)
+                            end
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs/identifiers/european_norm.rb

@@ -1,31 +1,51 @@
-  module Pubid
-    module CenPfs
-      module Identifiers
-        # Concrete European Norm identifier type (PFS type `european_norm`).
-        class EuropeanNorm < Identifier
+module Pubid
+  module CenPfs
+    module Identifiers
+      # Concrete European Norm identifier type (PFS type `european_norm`).
+      class EuropeanNorm < Identifier
           TYPED_STAGES = [
-            Pubid::Components::TypedStage.new(
-              code: :puben,
-              stage_code: :published,
-              type_code: :en,
-              abbr: ["EN"],
-              name: "European Norm",
-              harmonized_stages: [],
-            ),
+          ::Pubid::Components::TypedStage.new(
+            code: :puben, stage_code: :published,
+            type_code: :en, abbr: ["EN"],
+            name: "European Norm", harmonized_stages: [],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pren, stage_code: :proposal,
+            type_code: :en, abbr: ["prEN"],
+            name: "pren", harmonized_stages: [],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fpren, stage_code: :final_proposal,
+            type_code: :en, abbr: ["FprEN"],
+            name: "fpren", harmonized_stages: [],
+          ),
           ].freeze
 
-          def self.type
-            { key: :en, web: :"european-norm", title: "European Norm", short: "EN" }
-          end
+        def self.type
+          { key: :en, web: :"european-norm", title: "European Norm", short: "EN" }
+        end
+
+        # The publisher default (feature 5): the type's own token
+        # when the type is its designation, else the scheme default.
+        def self.default_publisher
+          ::Pubid::Components::Publisher.new(body: "EN")
+        end
+
+        attribute :publisher, ::Pubid::Components::Publisher, default: -> { self.class.default_publisher }
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.default_type }
+
+        def self.default_type
+          ::Pubid::Components::Type.new(abbr: type[:short])
+        end
 
-          # The scheme-canonical wire tag declared in the definition:
-          # to_hash stays byte-identical with the scheme's coded
-          # flavor, and this flavor's own from_hash routes the tag
-          # to this class.
-          def self.polymorphic_name
-            "pubid:cencenelec:european-norm"
-          end
+        # The scheme-canonical wire tag declared in the definition:
+        # to_hash stays byte-identical with the scheme's coded
+        # flavor, and this flavor's own from_hash routes the tag
+        # to this class.
+        def self.polymorphic_name
+          "pubid:cencenelec:european-norm"
         end
       end
     end
   end
+end

data/lib/pubid/cen_pfs/identifiers/european_prestandard.rb

@@ -0,0 +1,55 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # Concrete European Prestandard identifier type (PFS type `european_prestandard`).
+      class EuropeanPrestandard < Identifier
+          TYPED_STAGES = [
+          ].freeze
+
+        def self.type
+          { key: :env, web: :european_prestandard, title: "European Prestandard", short: "ENV" }
+        end
+
+        # The publisher default (feature 5): the type's own token
+        # when the type is its designation, else the scheme default.
+        def self.default_publisher
+          ::Pubid::Components::Publisher.new(body: "ENV")
+        end
+
+        attribute :publisher, ::Pubid::Components::Publisher, default: -> { self.class.default_publisher }
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.default_type }
+
+        def self.default_type
+          ::Pubid::Components::Type.new(abbr: type[:short])
+        end
+
+        # The adopted document (feature 4): the whole identity lives
+        # on the nested ISO/IEC identifier.
+        attribute :adopted, ::Pubid::Identifier, polymorphic: true
+
+        def root
+          adopted ? adopted.root : self
+        end
+
+        # MR "cen.iso.ts.21003-7": the publisher group fused, then the
+        # adopted document's own MR string in place of a number.
+        def mr_publisher
+          mr_join(*([publisher] + Array(copublishers)).compact
+            .map { |p| p.to_s.downcase })
+        end
+
+        def mr_number_with_part
+          adopted ? adopted.to_mr_string : super
+        end
+
+        # The scheme-canonical wire tag declared in the definition:
+        # to_hash stays byte-identical with the scheme's coded
+        # flavor, and this flavor's own from_hash routes the tag
+        # to this class.
+        def self.polymorphic_name
+          "pubid:cencenelec:european-prestandard"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs/identifiers/european_specification.rb

@@ -0,0 +1,36 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # Concrete European Specification identifier type (PFS type `european_specification`).
+      class EuropeanSpecification < Identifier
+          TYPED_STAGES = [
+          ].freeze
+
+        def self.type
+          { key: :es, web: :european_specification, title: "European Specification", short: "ES" }
+        end
+
+        # The publisher default (feature 5): the type's own token
+        # when the type is its designation, else the scheme default.
+        def self.default_publisher
+          ::Pubid::Components::Publisher.new(body: "ES")
+        end
+
+        attribute :publisher, ::Pubid::Components::Publisher, default: -> { self.class.default_publisher }
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.default_type }
+
+        def self.default_type
+          ::Pubid::Components::Type.new(abbr: type[:short])
+        end
+
+        # The scheme-canonical wire tag declared in the definition:
+        # to_hash stays byte-identical with the scheme's coded
+        # flavor, and this flavor's own from_hash routes the tag
+        # to this class.
+        def self.polymorphic_name
+          "pubid:cencenelec:european-specification"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs/identifiers/fragment.rb

@@ -0,0 +1,28 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # The fragment wrapper: a fragment of the amendment it
+      # wraps; the fragment ordinal is its own `number`.
+      class Fragment < ::Pubid::CenPfs::Identifier
+        attribute :base, ::Pubid::CenPfs::Identifier
+        attribute :number, :string
+
+        def base_document
+          base&.base_document || self
+        end
+
+        def drop_supplements
+          base || self
+        end
+
+        def mr_supplement_suffix
+          mr_join_segments("frag", number)
+        end
+
+        def self.polymorphic_name
+          "pubid:cencenelec:fragment"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # Concrete Guide identifier type (PFS type `guide`).
+      class Guide < Identifier
+          TYPED_STAGES = [
+          ].freeze
+
+        def self.type
+          { key: :guide, web: :guide, title: "Guide", short: "Guide" }
+        end
+
+        # The publisher default (feature 5): the type's own token
+        # when the type is its designation, else the scheme default.
+        def self.default_publisher
+          ::Pubid::Components::Publisher.new(body: "EN")
+        end
+
+        attribute :publisher, ::Pubid::Components::Publisher, default: -> { self.class.default_publisher }
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.default_type }
+
+        def self.default_type
+          ::Pubid::Components::Type.new(abbr: type[:short])
+        end
+
+        # The scheme-canonical wire tag declared in the definition:
+        # to_hash stays byte-identical with the scheme's coded
+        # flavor, and this flavor's own from_hash routes the tag
+        # to this class.
+        def self.polymorphic_name
+          "pubid:cencenelec:guide"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs/identifiers/harmonization_document.rb

@@ -0,0 +1,36 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # Concrete Harmonization Document identifier type (PFS type `harmonization_document`).
+      class HarmonizationDocument < Identifier
+          TYPED_STAGES = [
+          ].freeze
+
+        def self.type
+          { key: :hd, web: :harmonization_document, title: "Harmonization Document", short: "HD" }
+        end
+
+        # The publisher default (feature 5): the type's own token
+        # when the type is its designation, else the scheme default.
+        def self.default_publisher
+          ::Pubid::Components::Publisher.new(body: "HD")
+        end
+
+        attribute :publisher, ::Pubid::Components::Publisher, default: -> { self.class.default_publisher }
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.default_type }
+
+        def self.default_type
+          ::Pubid::Components::Type.new(abbr: type[:short])
+        end
+
+        # The scheme-canonical wire tag declared in the definition:
+        # to_hash stays byte-identical with the scheme's coded
+        # flavor, and this flavor's own from_hash routes the tag
+        # to this class.
+        def self.polymorphic_name
+          "pubid:cencenelec:harmonization-document"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs/identifiers/supplement.rb

@@ -0,0 +1,39 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # The supplement wrapper base: the wrapper owns its ordinal
+      # and the base identifier; every delegated attribute reads
+      # through (the coded SupplementIdentifier shape).
+      class Supplement < ::Pubid::CenPfs::Identifier
+        attribute :base, ::Pubid::CenPfs::Identifier
+        attribute :number, :string
+        attribute :year, :string
+        attribute :month, :string
+
+        def base_document
+          base&.base_document || self
+        end
+
+        def drop_supplements
+          base || self
+        end
+
+        # The wrapper's date: "2016-11", "2003", or nil.
+        def supplement_date
+          return nil unless year
+
+          [year, month].compact.reject(&:empty?).join("-")
+        end
+
+        # The printed notation: the kind face, the ordinal (absent
+        # for an unnumbered corrigendum) and the declared date tail.
+        # The bare notation; the renderer's walkers add the
+        # standalone slash and the consolidated plus themselves.
+        def supplement_notation
+          "#{self.class.face}#{number}#{year ? ":#{year}" : ''}#{month ? "-#{month}" : ''}"
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # Concrete Technical Report identifier type (PFS type `technical_report`).
+      class TechnicalReport < Identifier
+          TYPED_STAGES = [
+          ].freeze
+
+        def self.type
+          { key: :tr, web: :technical_report, title: "Technical Report", short: "TR" }
+        end
+
+        # The publisher default (feature 5): the type's own token
+        # when the type is its designation, else the scheme default.
+        def self.default_publisher
+          ::Pubid::Components::Publisher.new(body: "EN")
+        end
+
+        attribute :publisher, ::Pubid::Components::Publisher, default: -> { self.class.default_publisher }
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.default_type }
+
+        def self.default_type
+          ::Pubid::Components::Type.new(abbr: type[:short])
+        end
+
+        # The scheme-canonical wire tag declared in the definition:
+        # to_hash stays byte-identical with the scheme's coded
+        # flavor, and this flavor's own from_hash routes the tag
+        # to this class.
+        def self.polymorphic_name
+          "pubid:cencenelec:technical-report"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs/identifiers/technical_specification.rb

@@ -0,0 +1,36 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # Concrete Technical Specification identifier type (PFS type `technical_specification`).
+      class TechnicalSpecification < Identifier
+          TYPED_STAGES = [
+          ].freeze
+
+        def self.type
+          { key: :ts, web: :technical_specification, title: "Technical Specification", short: "TS" }
+        end
+
+        # The publisher default (feature 5): the type's own token
+        # when the type is its designation, else the scheme default.
+        def self.default_publisher
+          ::Pubid::Components::Publisher.new(body: "EN")
+        end
+
+        attribute :publisher, ::Pubid::Components::Publisher, default: -> { self.class.default_publisher }
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.default_type }
+
+        def self.default_type
+          ::Pubid::Components::Type.new(abbr: type[:short])
+        end
+
+        # The scheme-canonical wire tag declared in the definition:
+        # to_hash stays byte-identical with the scheme's coded
+        # flavor, and this flavor's own from_hash routes the tag
+        # to this class.
+        def self.polymorphic_name
+          "pubid:cencenelec:technical-specification"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs/identifiers.rb

@@ -1,7 +1,21 @@
 module Pubid
   module CenPfs
     module Identifiers
-      autoload :EuropeanNorm, "#{__dir__}/identifiers/european_norm"
+            autoload :EuropeanNorm, "#{__dir__}/identifiers/european_norm"
+          autoload :AdoptedEuropeanNorm, "#{__dir__}/identifiers/adopted_european_norm"
+          autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+          autoload :TechnicalSpecification, "#{__dir__}/identifiers/technical_specification"
+          autoload :Guide, "#{__dir__}/identifiers/guide"
+          autoload :CenReport, "#{__dir__}/identifiers/cen_report"
+          autoload :CenWorkshopAgreement, "#{__dir__}/identifiers/cen_workshop_agreement"
+          autoload :EuropeanSpecification, "#{__dir__}/identifiers/european_specification"
+          autoload :EuropeanPrestandard, "#{__dir__}/identifiers/european_prestandard"
+          autoload :HarmonizationDocument, "#{__dir__}/identifiers/harmonization_document"
+          autoload :Supplement, "#{__dir__}/identifiers/supplement"
+          autoload :Amendment, "#{__dir__}/identifiers/amendment"
+          autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+          autoload :ConsolidatedIdentifier, "#{__dir__}/identifiers/consolidated_identifier"
+          autoload :Fragment, "#{__dir__}/identifiers/fragment"
     end
   end
 end

data/lib/pubid/cen_pfs/pubid_urn_schema.rb

@@ -6,10 +6,29 @@
       # namespace; identifiers carry the scheme's wire tag, so their
       # pubid URNs encode through the scheme's own schema.
       PubidUrnSchema = Pubid::PubidUrn.define("cen_pfs") do
+        atom "publisher", "pub"
+        atom "copublishers", "co", kind: :list
         atom "part", "part"
         atom "year", "year"
+        atom "version", "v"
+        atom "stage", "stage"
+        atom "adopted", "adopted", kind: :id
+        atom "identifiers", "ids", kind: :ids
+        type "pubid:cencenelec:adopted-european-norm", "aen", core: []
+        type "pubid:cencenelec:amendment", "amd", core: []
+        type "pubid:cencenelec:cen-report", "cr", core: []
+        type "pubid:cencenelec:cen-workshop-agreement", "cwa", core: []
+        type "pubid:cencenelec:consolidated-identifier", "consol", core: []
+        type "pubid:cencenelec:corrigendum", "cor", core: []
+        type "pubid:cencenelec:european-norm", "en", core: []
+        type "pubid:cencenelec:european-prestandard", "ep", core: []
+        type "pubid:cencenelec:european-specification", "es", core: []
+        type "pubid:cencenelec:fragment", "fragment", core: []
+        type "pubid:cencenelec:guide", "guide", core: []
+        type "pubid:cencenelec:harmonization-document", "hd", core: []
         type "pubid:cencenelec:identifier", "id", core: []
-        type "pubid:cencenelec:european-norm", "en", core: ["number"]
+        type "pubid:cencenelec:technical-report", "tr", core: []
+        type "pubid:cencenelec:technical-specification", "ts", core: []
       end
     end
   end

data/lib/pubid/cen_pfs/renderer.rb

@@ -2,8 +2,57 @@ module Pubid
   module CenPfs
     # Human renderer, generated from the canonical template.
     class Renderer < ::Pubid::Renderers::Base
+      FACE_stage = {
+        "fpren" => "FprEN",
+        "pren" => "prEN",
+      }.freeze
       def render(**_opts)
-        "EN #{@id.number}#{"-#{@id.part}" if @id.part}#{":#{@id.date.year}" if @id.date&.year}"
+        f = render_fields(@id)
+        "#{if f[:stage] && f[:number]; "#{f[:stage]} #{f[:number]}#{("-#{f[:part]}") if f[:part]}#{("#{f[:version]}") if f[:version]}#{(":#{f[:year]}") if f[:year]}" elsif f[:publisher] && f[:guide] && f[:number]; "#{f[:publisher]}#{("#{f[:copublishers]}") if f[:copublishers]} #{f[:guide]} #{f[:number]}#{("-#{f[:part]}") if f[:part]}#{(":#{f[:year]}") if f[:year]}" elsif f[:publisher] && f[:adopted]; "#{f[:publisher]}#{("#{f[:copublishers]}") if f[:copublishers]} #{f[:adopted]}" elsif f[:publisher] && f[:number]; "#{f[:publisher]}#{("#{f[:copublishers]}") if f[:copublishers]}#{("/#{f[:type]}") if f[:type]} #{f[:number]}#{("-#{f[:part]}") if f[:part]}#{("#{f[:version]}") if f[:version]}#{(":#{f[:year]}") if f[:year]}"; end}#{("#{f[:supplements]}#{(" FRAG#{f[:fragment_number]}") if f[:fragment_number]}") if f[:supplements]}"
+      end
+
+      private
+
+      # The field view: a wrapper reads through to the wrapped
+      # standard and composes the printed run once — the standalone
+      # chain behind its slash, the consolidated members behind the
+      # plus — and the fragment face follows its base.
+      def render_fields(id)
+        root = id
+        run = +""
+        members = nil
+        frag = nil
+        if root.is_a?(Identifiers::Fragment)
+          frag = root.number
+          root = root.base
+        end
+        if root.is_a?(Identifiers::ConsolidatedIdentifier)
+          base, *consolidated = root.identifiers
+          members = consolidated
+          root = base
+        end
+        while root.is_a?(Identifiers::Supplement)
+          run.prepend("/#{root.supplement_notation}")
+          root = root.base
+        end
+        members&.each do |member|
+          run << "+#{member.supplement_notation}"
+        end
+        view = {
+          publisher: root.publisher&.respond_to?(:body) ? root.publisher.body : root.publisher,
+          copublishers: root.copublishers.to_a.any? ? root.copublishers.map { |item| "/#{item.respond_to?(:body) ? item.body : item}" }.join : nil,
+          stage: FACE_stage.fetch(root.typed_stage&.code&.to_s, root.typed_stage&.code&.to_s),
+          type: (v = root.type&.abbr) && ["TR", "TS"].include?(v) ? v : nil,
+          guide: (v = root.type&.abbr) && ["Guide"].include?(v) ? v : nil,
+          number: root.number,
+          part: root.part,
+          version: root.version,
+          year: root.date&.year,
+          adopted: root.respond_to?(:adopted) ? root.adopted : nil,
+        }
+        view[:supplements] = run.empty? ? nil : run
+        view[:fragment_number] = frag
+        view
       end
     end
   end

data/lib/pubid/cen_pfs/urn_generator.rb

@@ -1,12 +1,84 @@
 module Pubid
   module CenPfs
-    # The official URN generator, pinned to the scheme's declared
-    # namespace ("cen") so to_urn stays
-    # scheme-canonical under the compiled flavor key.
+    # The official URN generator: the scheme's declared namespace
+    # ("cen") and the ordered fused segments
+    # (feature 6) — the publisher group, the adopted document's
+    # fused MR string, the composed code, the year, the draft
+    # stage. A wrapper reads through to its subject and appends
+    # its declared chain; the consolidated bundle marks each
+    # member with the plus marker.
     class UrnGenerator < ::Pubid::UrnGenerator::Base
       def urn_namespace
         "cen"
       end
+
+      def generate
+        id = @identifier
+        members = nil
+        frag_segments = []
+        wrapper = []
+        if id.is_a?(Identifiers::Fragment)
+          frag_segments = wrapper_segments(id)
+          id = id.base
+        end
+        if id.is_a?(Identifiers::ConsolidatedIdentifier)
+          base, *consolidated = id.identifiers
+          members = consolidated
+          id = base
+        end
+        while id.is_a?(Identifiers::Supplement)
+          wrapper.prepend(*wrapper_segments(id))
+          id = id.base
+        end
+        @identifier = id
+        parts = ["urn", urn_namespace]
+        parts.concat(official_segments)
+        parts.concat(wrapper)
+        members&.each do |member|
+          parts << "plus"
+          parts.concat(wrapper_segments(member))
+        end
+        parts.concat(frag_segments)
+        parts.join(":")
+      end
+
+      private
+
+      def official_segments
+        segments = []
+        group = [@identifier.publisher&.respond_to?(:body) ? @identifier.publisher.body : @identifier.publisher,
+                *Array(@identifier.copublishers).map { |p| p.respond_to?(:body) ? p.body : p }].compact.map(&:to_s)
+                segments << group.map(&:downcase).join("-") unless group.empty?
+        adopted = @identifier.respond_to?(:adopted) ? @identifier.adopted : nil
+                mr = adopted&.to_mr_string
+                segments << mr.tr("._", "::") unless mr.nil? || mr.empty?
+        code = []
+        code << @identifier.number.to_s if @identifier.number
+        code << "-" + @identifier.part.to_s if @identifier.part
+        segments << code.join unless code.empty?
+        date = [@identifier.date&.year].compact
+        segments << date.join("-") unless date.empty?
+        stage = @identifier.typed_stage
+                code = stage&.stage_code
+                segments << "stage." + code.to_s if code && code.to_s != "published"
+        segments
+      end
+
+      # One wrapper's declared URN chain: the kind word, then the
+      # wrapper's columns (the ordinal, the year-month date).
+      def wrapper_segments(id)
+        segments = case id
+        when Identifiers::Amendment
+          ["amd", id.number, id.year]
+        when Identifiers::Corrigendum
+          ["cor", id.number, (id.respond_to?(:supplement_date) ? id.supplement_date : [id.year, id.month].compact.join("-") )]
+        when Identifiers::Fragment
+          ["frag", id.number]
+        else
+          []
+        end
+        segments.map(&:to_s).reject(&:empty?)
+      end
     end
   end
 end

data/lib/pubid/cen_pfs.rb

@@ -1,34 +1,25 @@
 # frozen_string_literal: true
 #
 # PFS-generated flavor — DO NOT EDIT BY HAND.
-# Source: definitions/cen.pfs (pfs:1) sha256:bc1edd5874f8938b5f946416a2b052d9d9b9df3d99f6c20a3d88fcab9ae1d70c
+# Source: definitions/cen.pfs (pfs:1) sha256:b8f2c00e392dbc03c1fddedad141afa7c930c5430738721b7df0ac69a371d028
 # Compiler: pubid/grammar/pfs 0.1.0 (baked with parsanol 1.3.126)
 # Regenerate: ruby scripts/pfs compile definitions/cen.pfs --as cen_pfs --ruby-out <dir>
 
 require "pubid"
 
 module Pubid
-  # CEN/CENELEC European Norms (module composition) flavor, compiled from its PFS definition
+  # CEN/CENELEC flavor, compiled from its PFS definition
   # (pubid/pubid#706). A compiled flavor is a peer of the coded
   # flavors: same registry, same input guards, same error
   # namespace, same URN contracts.
   module CenPfs
     extend Pubid::PrefixesSupport
 
-    PREFIXES = ["EN", "CEN/", "CLC/"].freeze
-    # The module composition the definition binds (issue #706 §4):
-    # each entry names the library module, the version it was bound
-    # at, and — where the module declares one — its IDENTITY
-    # composition (wrapper-with-adopted: the adopted document is
-    # the base). Carried so consumers and the wizard can
-    # introspect what the flavor is composed of.
-    MODULES = [
-      { name: "iso.inner", version: 1, identity: { composition: "wrapper-with-adopted", base_module: "iso.inner", adopted_field: :adopted } },
-      { name: "en.overlay", version: 1, identity: { composition: "wrapper-with-adopted", base_module: "iso.inner", adopted_field: :adopted } },
-      { name: "national.prefix", version: 1, identity: { composition: "wrapper-with-adopted", base_module: "iso.inner", adopted_field: :adopted } },
-      { name: "supplements.core", version: 1, identity: { composition: "wrapper-with-adopted", adopted_field: :base } },
-    ].freeze
-
+    PREFIXES = ["CEN", "CLC", "CENELEC", "EN", "CWA", "HD", "ES", "CR", "ENV"].freeze
+    # The adopted-base dispatch hook (the §4 coded escape hatch):
+    # vendored beside the generated classes — a missing hook file
+    # fails loudly on the first adoption, never silently.
+    autoload :AdoptedBase, "#{__dir__}/cen_pfs/adopted_base"
     autoload :Builder, "#{__dir__}/cen_pfs/builder"
     autoload :Identifier, "#{__dir__}/cen_pfs/identifier"
     autoload :Identifiers, "#{__dir__}/cen_pfs/identifiers"

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.26"
+  VERSION = "2.0.28"
 end