pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/errors.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "pubid"
+require "parslet"
+
+module Pubid
+  # Every failure pubid raises.
+  #
+  # The three classes below have three different superclasses, chosen so that
+  # code written against the old contract keeps working: relaton-cli rescues
+  # `Parslet::ParseFailed`, and the input guards have always raised
+  # `ArgumentError`. What unifies them is the marker module
+  # {Pubid::Errors::Error}, which every one of them includes, so a caller that
+  # wants "pubid could not do this" writes one rescue:
+  #
+  #   begin
+  #     Pubid::Iso.parse(reference)
+  #   rescue Pubid::Errors::Error => e
+  #     warn e.message
+  #   end
+  #
+  # A URN failure deliberately does not inherit `Parslet::ParseFailed`: no
+  # grammar runs, so there is no parse failure to report.
+  module Errors
+    # Marker module included by every pubid error. Rescue this to catch all
+    # of them, whatever their superclass.
+    module Error; end
+
+    # A printed identifier could not be turned into an identifier object.
+    #
+    # Raised for a grammar rejection, and also for the few flavors that reject
+    # an input before the grammar runs (a CSA comment line, a bad ISBN check
+    # digit). Those synthetic failures carry no parslet cause, so
+    # {#parse_failure_cause} is nillable — check it before calling
+    # `ascii_tree` on it.
+    #
+    # v1's `Pubid::Core::Errors::ParseError` flattened the cause into the
+    # message and threw the object away. This one keeps it.
+    class ParseError < ::Parslet::ParseFailed
+      include Error
+
+      # The string that could not be parsed, when it is known.
+      # @return [String, nil]
+      attr_reader :input
+
+      # The flavor whose grammar rejected the input, lowercased ("iso").
+      #
+      # This is the flavor that actually ran, which is not always the one the
+      # caller named: `Pubid::Iso.parse("ITU-T G.711")` routes through the
+      # MR-string parser into ITU, and reports "itu".
+      # @return [String, nil]
+      attr_reader :flavor
+
+      # @param message [String]
+      # @param parse_failure_cause [Parslet::Cause, nil] parslet's structured
+      #   cause, nil for a failure raised without running a grammar
+      # @param input [String, nil]
+      # @param flavor [String, nil]
+      def initialize(message, parse_failure_cause = nil, input: nil,
+                     flavor: nil)
+        super(message, parse_failure_cause)
+        @input = input
+        @flavor = flavor
+      end
+    end
+
+    # A URN could not be turned into an identifier object.
+    class UrnParseError < ::StandardError
+      include Error
+    end
+
+    # The input was not a String, or was longer than {Pubid::MAX_INPUT_LENGTH}.
+    #
+    # Inherits `ArgumentError` because that is what the guards have always
+    # raised, and because the input is wrong in kind rather than unparseable.
+    class InvalidInputError < ::ArgumentError
+      include Error
+    end
+  end
+end

data/lib/pubid/etsi/builder.rb

@@ -52,9 +52,14 @@ module Pubid
         version = build_version(data)
         date = build_date(data)
 
+        # The code fields are stored as flat index columns on the leaf (see
+        # EtsiStandard) — `number` is what relaton-index keys on — so the Code
+        # object built above is unpacked rather than assigned.
         Identifiers::EtsiStandard.new(
           type: data[:type].to_s,
-          code: code,
+          number: code.number,
+          minor: code.minor,
+          parts: code.parts || [],
           version: version,
           date: date,
         )
@@ -95,19 +100,23 @@ module Pubid
       end
 
       def build_version(data)
-        # Handle both version and edition
+        # Handle both version and edition. A partial reference omits both, in
+        # which case version is left nil (not defaulted) so exclude/matches?
+        # treat it as a wildcard.
         if data[:version]
           Components::Version.new(version: data[:version].to_s,
                                   is_edition: false)
         elsif data[:edition]
           Components::Version.new(version: data[:edition].to_s,
                                   is_edition: true)
-        else
-          Components::Version.new(version: "1.0.0", is_edition: false)
         end
       end
 
       def build_date(data)
+        # A partial reference omits the date; leave it nil rather than building
+        # an empty Date, so the canonical to_hash drops it entirely.
+        return nil unless data[:year]
+
         Pubid::Components::Date.new(
           year: data[:year].to_s,
           month: data[:month].to_s,

data/lib/pubid/etsi/identifier.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
 # Pubid::Etsi::Identifier is the ETSI base class (a real Pubid::Identifier
-# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
-# live in identifiers/base.rb. This file just ensures it is loaded.
-require_relative "identifiers/base"
+# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.

data/lib/pubid/etsi/identifiers/base.rb

@@ -2,19 +2,27 @@
 
 module Pubid
   module Etsi
-    # Base class for all ETSI identifiers. Canonical name Pubid::Etsi::Identifier
-    # (Identifiers::Base is a back-compat alias); every concrete ETSI identifier
-    # descends from it.
+    # Base class for all ETSI identifiers. Canonical name Pubid::Etsi::Identifier;
+    # every concrete ETSI identifier descends from it.
     class Identifier < ::Pubid::Identifier
+      # Let Parslet::ParseFailed propagate on a bad reference (matching ISO), so
+      # relaton-cli's `rescue Parslet::ParseFailed` fetch handler catches it
+      # instead of a bare RuntimeError.
       def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         parsed = Parser.parse(identifier)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse ETSI identifier '#{identifier}': #{e.message}"
       end
 
       attribute :type, :string
-      attribute :code, Pubid::Etsi::Components::Code
       attribute :version, Pubid::Etsi::Components::Version
       attribute :date, Pubid::Components::Date
       # Stored as a plain string (always "ETSI") so it round-trips through
@@ -31,12 +39,36 @@ module Pubid
           version == other.version &&
           date == other.date
       end
-    end
 
-    module Identifiers
-      # Backward-compatible alias: ETSI's base class used to be
-      # Pubid::Etsi::Identifiers::Base. It is now Pubid::Etsi::Identifier.
-      Base = Pubid::Etsi::Identifier
+      # The document code is composed from the split index columns declared on
+      # EtsiStandard (`number`/`minor`/`parts`). Returning nil here keeps `==`
+      # and the URN generator total for the abstract base and for a supplement
+      # whose own base is missing; EtsiStandard composes the real value and
+      # SupplementIdentifier delegates to its base.
+      def code
+        nil
+      end
+
+      # `parts` is a plain collection attribute on the leaf, so the base
+      # #exclude reaches it directly and nils it. It must come back as an EMPTY
+      # ARRAY instead: a part-less reference parses with `parts` defaulting to
+      # [], so a nil here would make `==` — and therefore #matches? — fail
+      # against exactly the reference this exclusion exists to match. Same
+      # "reset the whole cluster" rule recorded for CSA's year and IEEE's
+      # year/month/day in CLAUDE.md.
+      #
+      # This also covers supplements: the base #exclude recurses into the
+      # nested `base` identifier through exclude_from_nested, which re-enters
+      # this method on the inner EtsiStandard.
+      def exclude(*args)
+        result = super
+        part_keys = args & %i[part parts]
+        if !part_keys.empty? && result.respond_to?(:parts=)
+          result.parts = []
+        end
+        result
+      end
     end
+
   end
 end

data/lib/pubid/etsi/identifiers/etsi_standard.rb

@@ -4,15 +4,218 @@ module Pubid
   module Etsi
     module Identifiers
       # Single class for all ETSI standard types
-      # Type is passed as parameter: EN, ES, EG, TS, ETR, ETS, I-ETS, TBR, TCRTR, NET, GR, GS, SR, TR, GTS
+      # Type is passed as parameter: EN, ES, EG, TS, ETR, ETS, I-ETS, TBR,
+      # TCRTR, NET, GR, GS, SR, TR, GTS
       # Format: ETSI TYPE CODE VERSION (DATE)
       # Examples:
       #   ETSI GS ZSM 012 V1.1.1 (2022-12)
       #   ETSI GR ZSM 009-3 V1.1.1 (2023-08)
       #   ETSI GTS GSM 02.01 V5.5.0 (1999-01)
-      class EtsiStandard < Base
-        # Type is stored in @type attribute from Base
-        # All rendering handled by Base class
+      class EtsiStandard < Identifier
+        # Type is stored in @type attribute from Identifier
+        # All rendering handled by Identifier class
+
+        # --- Index columns -------------------------------------------------
+        #
+        # relaton-index sorts and bsearches every row on `id.root.number.to_s`,
+        # so the document number must be reachable as `number`. ETSI used to
+        # keep it inside an Etsi::Components::Code under a `code` attribute,
+        # leaving the inherited `number` nil and every index row keyed "".
+        #
+        # The three Code fields are now plain sibling attributes, which is the
+        # shape the serialized hash ALREADY had — the converters below merely
+        # read them directly instead of reaching through `code`, so the wire
+        # format is byte-identical and relaton-data-etsi's published index-v2
+        # needs no regeneration.
+        #
+        # `number` holds the BARE number ("300 175"), never the part, so all
+        # parts of a document share one index bucket and a part-less reference
+        # finds them all — the IEEE/ISO semantics documented in CLAUDE.md.
+        #
+        # LANDMINE: these redeclare attributes inherited from ::Pubid::Identifier
+        # (`number` is a Components::Code there, and Etsi::Components::Code is
+        # NOT a subclass of it). That resolves nondeterministically under
+        # multi-flavor load when declared on a class others inherit from, so it
+        # is confined to this LEAF — EtsiStandard has no subclasses, while the
+        # shared Pubid::Etsi::Identifier is also SupplementIdentifier's parent
+        # and must stay untouched. spec/pubid/etsi/root_number_spec.rb carries
+        # the tripwire and is only meaningful under the full `rake` suite.
+        attribute :number, :string
+        attribute :minor, :string
+        attribute :parts, :string, collection: true, default: -> { [] }
+
+        # Compact serialization (mirrors ISO/JCGM/OIML): the code fields are
+        # bare scalars (`number`, a `parts` array and, rarely, a `minor`);
+        # Version flattens to a scalar `version` string with an `is_edition`
+        # boolean flag (omitted when false); Date flattens to top-level
+        # year/month/day. The constant `publisher` ("ETSI") is intentionally
+        # NOT mapped — it is reconstructed on load from its attribute default,
+        # keeping the hash compact.
+        #
+        # This block lives on EtsiStandard (a leaf) rather than the shared Identifier:
+        # SupplementIdentifier is a sibling that DELEGATES type/code/version and
+        # date to its inner `base`, so a block on Identifier would be inherited-and-
+        # merged by the supplement and re-emit every delegated field at the top.
+        key_value do
+          map "_type",      to: :_type
+          map "type",       to: :type
+          map "number",     to: :number
+          map "parts",      to: :parts
+          map "minor",      to: :minor
+          map "version",    with: { to: :version_to_kv, from: :version_from_kv }
+          map "is_edition", with: { to: :edition_to_kv, from: :edition_from_kv }
+          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 }
+        end
+
+        # The composed document code, rebuilt on demand from the split columns
+        # so the renderer, the URN generator and #== keep one place to ask for
+        # the printed form ("300 175-1"). Deliberately NOT an attribute and NOT
+        # memoised: `number`/`parts` are writable (the base #exclude rebuilds
+        # through them), so a cached Code would go stale.
+        #
+        # nil when there is no number, preserving the old nil-`code` semantics
+        # the URN generator branches on.
+        def code
+          return nil if number.nil?
+
+          Pubid::Etsi::Components::Code.new(
+            number: number,
+            minor: minor,
+            parts: parts || [],
+          )
+        end
+
+        # MR slug number segment.
+        #
+        # The base hook reads the inherited `number` and `part`; ETSI kept
+        # neither, so before the index columns landed every ETSI slug was just
+        # `etsi.<date>` — 454 distinct slugs for 24,724 documents, and
+        # `to_slug` is what consumers use as an output FILENAME.
+        #
+        # Two things the base hook cannot do for ETSI:
+        #   * the parts live in the `parts` collection, not the inherited
+        #     scalar `part`, so they must be appended here or every part of a
+        #     document collapses onto one slug;
+        #   * an ETSI number legitimately contains a SPACE ("300 175", "GSM
+        #     02.01"), which is outside the [a-z0-9.-] charset Renderers::MrString
+        #     documents and guarantees. Sanitize BY CHARSET rather than by an
+        #     enumerated escape list (the BIPM `mr_slug` precedent in
+        #     CLAUDE.md), so a character added later cannot reach a filename.
+        # `minor` is included because it is identity-bearing everywhere else —
+        # Code#== compares it, Code#to_s renders it and the URN carries it — so
+        # omitting it here would let two distinct documents share one filename.
+        # No fixture populates it today; it is in the grammar, so it is here.
+        def mr_number_with_part
+          return nil if number.nil?
+
+          mr_sanitize([number, minor, *Array(parts)].compact.join("-"))
+        end
+
+        # ETSI's identity is type + code + version + date (see
+        # Pubid::Etsi::Identifier#==), so all four must reach the slug —
+        # CLAUDE.md's rule that an identity-bearing marker has to appear on
+        # every identity surface, not just in `==`. The base hooks find
+        # neither: `mr_type` reads `typed_stage` (ETSI has none) and
+        # `mr_edition` reads `edition.number` (ETSI models the edition as
+        # `version`). Without these, "ETSI EN 300 729 V6.1.1 (2000-04)",
+        # "…V7.1.1 (2000-04)" and "ETSI ETS 300 729 ed.2 (2000-04)" all share
+        # one slug — i.e. one output filename.
+        def mr_type
+          type&.to_s&.downcase
+        end
+
+        def mr_edition
+          mr_sanitize(version&.version)
+        end
+
+        # Segment sanitizer. Renderers::MrString joins SEGMENTS with ".", so a
+        # dot inside one would break that structure — hence "." is replaced
+        # here even though it is inside the renderer's overall charset (the
+        # BIPM `bipm.si-brochure.9e-v3-01.e` precedent in CLAUDE.md). Filtering
+        # by charset rather than by an enumerated escape list keeps a character
+        # introduced later from leaking into a filename.
+        #
+        # Public purely to keep this file's surface flat, next to the
+        # lutaml-invoked converters below — it has no external callers and
+        # would work as well private.
+        #
+        # The emptiness check is on the OUTPUT, not just the input: a value
+        # made entirely of characters outside the charset collapses to "-" and
+        # then to "", and an empty string is truthy in Ruby, so it would reach
+        # Renderers::MrString as a blank segment and produce a double dot in
+        # the joined slug. Unreachable from today's grammar, which only feeds
+        # digit/alnum captures here — but not structurally prevented.
+        def mr_sanitize(value)
+          return nil if value.nil? || value.to_s.empty?
+
+          sanitized = value.to_s.downcase
+            .gsub(/[^a-z0-9-]+/, "-").gsub(/\A-+|-+\z/, "")
+          sanitized.empty? ? nil : sanitized
+        end
+
+        # --- Version flattened to scalar version + is_edition flag ---
+        def version_to_kv(model, doc)
+          emit_kv(doc, "version", model.version&.version)
+        end
+
+        def version_from_kv(model, value)
+          version_for(model).version = value.to_s
+        end
+
+        def edition_to_kv(model, doc)
+          return unless model.version&.is_edition
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new("is_edition", true),
+          )
+        end
+
+        def edition_from_kv(model, value)
+          version_for(model).is_edition = value
+        end
+
+        # --- Date flattened to top-level year/month/day scalars ---
+        def year_to_kv(model, doc)
+          emit_kv(doc, "year", model.date&.year)
+        end
+
+        def month_to_kv(model, doc)
+          emit_kv(doc, "month", model.date&.month)
+        end
+
+        def day_to_kv(model, doc)
+          emit_kv(doc, "day", model.date&.day)
+        end
+
+        def year_from_kv(model, value)
+          date_for(model).year = value.to_s
+        end
+
+        def month_from_kv(model, value)
+          date_for(model).month = value.to_s
+        end
+
+        def day_from_kv(model, value)
+          date_for(model).day = value.to_s
+        end
+
+        def emit_kv(doc, key, value)
+          return if value.nil? || value.to_s.empty?
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new(key, value.to_s),
+          )
+        end
+
+        def version_for(model)
+          model.version ||= Pubid::Etsi::Components::Version.new
+        end
+
+        def date_for(model)
+          model.date ||= Pubid::Components::Date.new
+        end
       end
     end
   end

data/lib/pubid/etsi/identifiers/supplement_identifier.rb

@@ -3,11 +3,43 @@
 module Pubid
   module Etsi
     module Identifiers
-      # Base class for ETSI supplements (Amendment, Corrigendum)
-      class SupplementIdentifier < Base
-        attribute :base, Pubid::Etsi::Identifiers::Base
+      # Identifier class for ETSI supplements (Amendment, Corrigendum)
+      class SupplementIdentifier < Identifier
+        attribute :base, Pubid::Etsi::Identifier
         attribute :number, :integer
 
+        # Compact serialization: a supplement carries only its own ordinal
+        # `number` (A1 -> 1) and the nested base standard under the compact key
+        # `base`. type/code/version/date are delegated to `base` (methods below)
+        # and NOT re-emitted here, so the old redundant duplication is gone.
+        # This block is inherited unchanged by Amendment/Corrigendum.
+        key_value do
+          map "_type",  to: :_type
+          map "number", to: :number
+          map "base",   with: { to: :base_to_kv, from: :base_from_kv }
+        end
+
+        # Serialize the base via its own to_hash so it collapses to the compact
+        # EtsiStandard shape.
+        def base_to_kv(model, doc)
+          return unless model.base
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new(
+              "base", model.base.to_hash
+            ),
+          )
+        end
+
+        # Re-dispatch through the flavor base so `_type` resolves to the
+        # concrete EtsiStandard; a bare polymorphic cast would rebuild a plain
+        # Identifier and lose the subclass (and its custom mappings). Mirrors JCGM.
+        def base_from_kv(model, value)
+          return unless value
+
+          model.base = Pubid::Etsi::Identifier.from_hash(value)
+        end
+
         # Inherit attributes from base
         def type
           base.type
@@ -56,6 +88,16 @@ module Pubid
           raise NotImplementedError
         end
 
+        # Make Renderers::MrString recurse into `base` instead of slugging the
+        # supplement flat. Without this the flat path reads the supplement's own
+        # `number` — its ordinal, 1 — and the base document is dropped entirely,
+        # so every "/C1" corrigendum published in one month shared the slug
+        # `etsi.1.<date>`. `to_slug` is an output FILENAME, so that is an
+        # overwrite. Same fix as ITU's AnnexOfRecommendation (see CLAUDE.md).
+        def mr_supplement_suffix
+          [supplement_notation.to_s.downcase, number].compact.join(".")
+        end
+
         def ==(other)
           return false unless other.is_a?(SupplementIdentifier)
           return false unless other.class == self.class

data/lib/pubid/etsi/identifiers.rb

@@ -4,7 +4,6 @@ module Pubid
   module Etsi
     module Identifiers
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
-      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :EtsiStandard, "#{__dir__}/identifiers/etsi_standard"
       autoload :SupplementIdentifier,

data/lib/pubid/etsi/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Etsi
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # Basic elements
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }
@@ -114,13 +114,19 @@ module Pubid
       end
 
       # Main identifier
+      #
+      # The mandatory core is `etsi_prefix type number` (+ optional
+      # minor/parts/supplements), mirroring ISO. The version/edition and date
+      # suffixes are optional so a partial reference (e.g. "ETSI GS ZSM 012")
+      # parses with version/date left nil. Each `.maybe` guards its own leading
+      # space so no trailing space is demanded when the suffix is absent.
       rule(:identifier) do
         etsi_prefix >>
           type >> space >>
           number >> minor.maybe >> parts >>
           supplements.maybe >>
-          space >> version_or_edition >>
-          space >> date_part
+          (space >> version_or_edition).maybe >>
+          (space >> date_part).maybe
       end
 
       rule(:root) { identifier }

data/lib/pubid/etsi/renderer.rb

@@ -27,7 +27,10 @@ module Pubid
 
       def render_base(id)
         result = "#{id.publisher} #{id.type} #{id.code}"
-        result += " #{id.version} (#{id.date.render})"
+        # version/date are optional on partial references; append each only when
+        # present so a partial id renders without a stray " V… ()" suffix.
+        result += " #{id.version}" if id.version
+        result += " (#{id.date.render})" if id.date
         result
       end
 
@@ -35,7 +38,10 @@ module Pubid
         supplement_notations = id.collect_supplement_notations(id, [])
         actual_base = id.find_actual_base(id.base)
         code_with_supplements = "#{actual_base.code}#{supplement_notations.join}"
-        "#{actual_base.publisher} #{actual_base.type} #{code_with_supplements} #{actual_base.version} (#{actual_base.date.render})"
+        result = "#{actual_base.publisher} #{actual_base.type} #{code_with_supplements}"
+        result += " #{actual_base.version}" if actual_base.version
+        result += " (#{actual_base.date.render})" if actual_base.date
+        result
       end
     end
   end

data/lib/pubid/etsi.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 require "lutaml/model"
 
 module Pubid
@@ -13,7 +14,7 @@ module Pubid
 
     autoload :Builder, "#{__dir__}/etsi/builder"
     autoload :Components, "#{__dir__}/etsi/components"
-    autoload :Identifier, "#{__dir__}/etsi/identifier"
+    autoload :Identifier, "#{__dir__}/etsi/identifiers/base"
     autoload :Identifiers, "#{__dir__}/etsi/identifiers"
     autoload :Parser, "#{__dir__}/etsi/parser"
     autoload :Renderer, "#{__dir__}/etsi/renderer"
@@ -25,8 +26,8 @@ module Pubid
     end
 
     # Per-flavor format registry: inherits global formats, overrides :human
-    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifiers::Base.format_registry.register(:human, renderer: Etsi::Renderer)
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Etsi::Renderer)
 
     # Auto-discover all identifier types from the Identifiers namespace
     # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
@@ -34,9 +35,9 @@ module Pubid
       @identifier_types ||= Identifiers.constants
         .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
         .select { |c| c.is_a?(Class) && c < Pubid::Identifier }
-        # Exclude the flavor base itself by identity (Identifiers::Base is now an
+        # Exclude the flavor base itself by identity (Identifier is now an
         # alias for Pubid::Etsi::Identifier, so name-based matching misses it).
-        .reject { |c| c == Identifiers::Base }
+        .reject { |c| c == Identifier }
     end
 
     # Build typed stage index from identifier types

data/lib/pubid/evs/builder.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    # Builds an EVS national adoption from the composed parse tree: the
+    # structured :adopted subtree (produced by the embedded CEN grammar) goes
+    # straight to the CEN/CENELEC builder as data — no string
+    # re-serialization anywhere.
+    class Builder < Pubid::Builder::Base
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        data = flatten_array(data) if data.is_a?(Array)
+
+        adopted = Pubid::CenCenelec::Builder.build(data[:adopted])
+
+        Identifiers::NationalAdoption.new(
+          adopted_identifier: adopted,
+          separator: data[:evs_separator] || "-",
+        )
+      end
+    end
+  end
+end

data/lib/pubid/evs/identifier.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    # An EVS national adoption wraps a CEN identifier the same way BSI's
+    # AdoptedEuropeanNorm does — polymorphic `adopted_identifier` so the
+    # wrapped object stays a real Pubid::CenCenelec identifier.
+    #
+    # Examples:
+    #   "EVS-EN 18216:2026"           (adopted_identifier: EN 18216:2026)
+    #   "EVS-EN ISO 14001:2026"       (adopted_identifier: EN ISO 14001:2026)
+    #   "EVS-EN ISO/IEC 27017:2026"   (adopted_identifier: EN ISO/IEC 27017:2026)
+    #   "EVS-EN ISO 9001:2015/A1:2024" (adopted_identifier: EN ISO 9001:2015/A1:2024)
+    class Identifier < ::Pubid::Identifier
+      attribute :adopted_identifier, ::Pubid::Identifier, polymorphic: true
+      # "-" or " " — preserves the printed separator ("EVS-EN" vs "EVS EN")
+      attribute :separator, :string, default: -> { "-" }
+
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      def self.parse(string)
+        unless string.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        Pubid::Evs.parse(string)
+      end
+    end
+  end
+end