pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.11

data/lib/pubid/easc.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Easc
     extend Pubid::PrefixesSupport

data/lib/pubid/ecma/builder.rb

@@ -10,21 +10,35 @@ module Pubid
       end
 
       def build(data)
-        if data[:tr_number]
-          Identifiers::TechnicalReport.new(number: data[:tr_number].to_s)
-        elsif data[:mem_number]
-          Identifiers::Memento.new(number: data[:mem_number].to_s)
-        else
-          build_standard(data)
-        end
+        klass, attrs =
+          if data[:tr_number]
+            [Identifiers::TechnicalReport, { number: data[:tr_number].to_s }]
+          elsif data[:mem_number]
+            [Identifiers::Memento, { number: data[:mem_number].to_s }]
+          else
+            [Identifiers::Standard, standard_attrs(data)]
+          end
+
+        klass.new(**attrs, **suffix_attrs(data))
       end
 
       private
 
-      def build_standard(data)
+      def standard_attrs(data)
         attrs = { number: data[:number].to_s }
         attrs[:part] = data[:part].to_s if data[:part]
-        Identifiers::Standard.new(**attrs)
+        attrs
+      end
+
+      # ` ed<N>` / ` vol<N>` attach after the type alternation, so a technical
+      # report and a memento carry them exactly as a standard does. An absent
+      # suffix produces no parse key at all, so the attribute stays unset and
+      # drops out of the canonical hash.
+      def suffix_attrs(data)
+        attrs = {}
+        attrs[:edition] = data[:edition].to_s if data[:edition]
+        attrs[:volume] = data[:volume].to_s if data[:volume]
+        attrs
       end
     end
   end

data/lib/pubid/ecma/identifier.rb

@@ -6,17 +6,32 @@ module Pubid
     # mirrors Pubid::Jis::Identifier. Concrete identifiers under
     # Pubid::Ecma::Identifiers descend from this class, so a parsed ECMA id is
     # an instance of Pubid::Ecma::Identifier. ECMA has no supplement layer.
+    # KEEP THIS CLASS BODY IN ONE FILE, AND NEVER REOPEN IT. `number`, `part`
+    # and `edition` below redeclare attributes the parent ::Pubid::Identifier
+    # types as components, which resolves nondeterministically under
+    # multi-flavor load if a subclass can snapshot a half-built attribute
+    # table. lutaml deep-dups the parent table into each subclass at
+    # class-definition time, and Ruby resolves this superclass constant to
+    # completion before opening any leaf body — so a single, never-reopened
+    # body is what makes the redeclaration safe. (The W3C precedent; IEEE's
+    # split base is the counter-shape.)
     class Identifier < ::Pubid::Identifier
       # The document number as a string (preserves any leading zeros). `part`
       # is only present for standards that split into parts (e.g. ECMA-418-1).
       attribute :number, :string
       attribute :part, :string
-      # Edition is separate metadata (the index stores {:id, :ed} and the YAML
-      # has edition.content); it is NOT part of the printed identifier string.
-      # Modelled as an optional string (decimal editions like "5.1" occur) that
-      # serializes in `to_hash` — so relaton preserves `:ed:` — but is omitted
-      # from `to_s`. No default, so it drops from the hash when unset.
+      # Edition is relaton's `:ed:` (the index stores {:id, :ed, :vol} and the
+      # YAML has edition.content). It is part of the printed identifier: the
+      # relaton index keys on a bare `to_s`, so without it all 22 editions of
+      # ECMA-74 collapse onto one key. An optional string, because decimal
+      # editions like "5.1" occur. No default, so it drops from the hash when
+      # unset.
       attribute :edition, :string
+      # Volume is relaton's `:vol:`. Only ECMA-269 edition 3 uses it: its four
+      # volumes share one docidentifier AND one title, so the volume is the only
+      # thing that distinguishes those four index rows. A plain string, the
+      # `number`/`edition` precedent, so it round-trips verbatim.
+      attribute :volume, :string
 
       # Polymorphic type map for lutaml::Model key_value (de)serialization:
       # maps each subclass's polymorphic_name to its class name so a stored
@@ -33,6 +48,7 @@ module Pubid
         map "number", to: :number
         map "part", to: :part
         map "edition", to: :edition
+        map "volume", to: :volume
       end
 
       # Publisher is always "ECMA". A plain constant (not a `publisher` method)
@@ -45,6 +61,11 @@ module Pubid
 
       # Basic string representation. Delegates to renderer. `with_publisher:
       # false` drops the ECMA token (e.g. "-411", "TR/84").
+      #
+      # The edition and volume suffixes are rendered by DEFAULT and are opted
+      # out of with `to_s(with_edition: false, with_volume: false)`. Both flags
+      # ride in `opts` to the renderer, which owns their defaults — see
+      # Pubid::Ecma::Renderer for why the default is "with".
       def to_s(with_publisher: true, **opts)
         @with_publisher = with_publisher
         render(format: :human, **opts)
@@ -56,20 +77,70 @@ module Pubid
         nil
       end
 
+      # ECMA keeps its publisher in the PUBLISHER constant rather than the
+      # inherited `publisher` attribute, so the base hook — `publisher&.to_s` —
+      # is nil and every ECMA slug would lose its "ecma." segment.
+      def mr_publisher
+        PUBLISHER.downcase
+      end
+
+      # The Builder picks an identifier class; it never sets a `typed_stage`,
+      # so the base hook is always nil. Without this, "ECMA-101" and
+      # "ECMA TR/101" produce the same slug — and `to_slug` is an output
+      # filename, so one document would overwrite the other.
+      def mr_type
+        type_prefix&.downcase
+      end
+
+      # ECMA's `edition` is a plain :string ("3", "5.1"), not a
+      # Components::Edition, so the base hook's `edition&.number` raises
+      # NoMethodError on every edition-bearing identifier.
+      def mr_edition
+        mr_marker("ed", edition)
+      end
+
+      # Volume is identity-bearing (ECMA-269 ed3 vol1..vol4 are four distinct
+      # documents), so it must reach the MR string as well as `to_s` and the
+      # URN. Fills the shared `mr_volume` slot in Renderers::MrString.
+      def mr_volume
+        mr_marker("vol", volume)
+      end
+
       # Parse an ECMA identifier string into an identifier object.
       # @param identifier [String] The ECMA identifier string to parse
       # @return [Identifier] The appropriate identifier object
-      # @raise [ArgumentError] If the input exceeds MAX_INPUT_LENGTH
-      # @raise [RuntimeError] If parsing fails
+      # @raise [Pubid::Errors::InvalidInputError]
+      #   If the input exceeds MAX_INPUT_LENGTH
+      # @raise [Pubid::Errors::ParseError] If parsing fails
       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 ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          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 ECMA identifier '#{identifier}': #{e.message}"
+      end
+
+      private
+
+      # Renderers::MrString joins SEGMENTS with ".", so a dot inside one would
+      # break the documented segment structure — hence "ed5-1" for edition
+      # "5.1". Sanitising by CHARSET rather than by an enumerated escape list,
+      # so a value added later cannot leak an unsafe character (the BIPM
+      # `mr_slug` precedent).
+      #
+      # The MR may be lossy here because nothing parses an ECMA MR back
+      # (`Parsers::MrString::FLAVOR_MAP` has no ECMA entry). The URN, which
+      # UrnParser inverts, keeps the dot instead.
+      def mr_marker(label, value)
+        return nil if value.nil? || value.to_s.empty?
+
+        "#{label}#{value.to_s.downcase.gsub(/[^a-z0-9]+/, '-')}"
       end
     end
   end

data/lib/pubid/ecma/parser.rb

@@ -6,16 +6,21 @@ module Pubid
   module Ecma
     # Parslet grammar for ECMA identifiers.
     #
-    # Four printed forms (see HANDOFFS/ecma.md):
+    # Four printed forms:
     #   ECMA-411          standard
     #   ECMA-418-1        standard with part
     #   ECMA TR/101       technical report
     #   ECMA MEM/1970     memento
     #
+    # Any of them may carry an edition and a volume, in that order:
+    #   ECMA-269 ed3      third edition
+    #   ECMA-402 ed5.1    decimal edition (real: ECMA-402)
+    #   ECMA-269 ed3 vol2 second volume of the third edition
+    #
     # Each branch captures its number under a distinct key so the builder can
     # pick the identifier class without a separate type token. Numbers are kept
     # as strings to preserve any leading zeros.
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:digits) { match["0-9"].repeat(1) }
 
       rule(:prefix) { str("ECMA") }
@@ -24,12 +29,42 @@ module Pubid
 
       rule(:mem) { str(" MEM/") >> digits.as(:mem_number) }
 
+      # Standards print with a hyphen ("ECMA-6"), but references are commonly
+      # written with a space ("ECMA 6"). Both parse; the renderer normalises to
+      # the hyphen, so the space form round-trips as "ECMA-6" by design and must
+      # never enter the byte-exact `pass` fixtures.
+      rule(:standard_separator) { str("-") | str(" ") }
+
       rule(:standard) do
-        str("-") >> digits.as(:number) >>
+        standard_separator >> digits.as(:number) >>
           (str("-") >> digits.as(:part)).maybe
       end
 
-      rule(:identifier) { prefix >> (tr | mem | standard) }
+      # Editions are not all integers: ECMA-402 ed5.1 is a real document. The
+      # value is stored verbatim so it renders and serializes unchanged.
+      rule(:edition_number) { digits >> (str(".") >> digits).repeat(0) }
+
+      rule(:edition) { str(" ed") >> edition_number.as(:edition) }
+
+      rule(:volume) { str(" vol") >> digits.as(:volume) }
+
+      # The suffixes attach AFTER the type alternation, so a technical report
+      # and a memento carry them exactly as a standard does.
+      #
+      # Two PEG facts this arrangement depends on:
+      #
+      # 1. `standard` cannot shadow " TR/" or " MEM/", because after the space
+      #    it demands a digit and "T"/"M" are not digits. Keeping tr|mem first
+      #    is belt-and-braces; the DISJOINT FIRST CHARACTER is the load-bearing
+      #    invariant.
+      # 2. Appending a sequence moves the alternation out of tail position, so
+      #    Parslet no longer threads consume_all into it and will not backtrack
+      #    into an alternative that already succeeded. A future branch that
+      #    could match a proper prefix of another branch's input would now fail
+      #    the whole parse instead of being rescued by the next alternative.
+      rule(:identifier) do
+        prefix >> (tr | mem | standard) >> edition.maybe >> volume.maybe
+      end
 
       rule(:root) { identifier }
 

data/lib/pubid/ecma/renderer.rb

@@ -5,28 +5,49 @@ module Pubid
     # Human-readable renderer for ECMA identifiers.
     #
     # Produces strings like:
-    #   "ECMA-411"        standard
-    #   "ECMA-418-1"      standard with part
-    #   "ECMA TR/101"     technical report
-    #   "ECMA MEM/1970"   memento
+    #   "ECMA-411"           standard
+    #   "ECMA-418-1"         standard with part
+    #   "ECMA TR/101"        technical report
+    #   "ECMA MEM/1970"      memento
+    #   "ECMA-269 ed3 vol2"  with the edition and volume suffixes
     #
     # With `with_publisher: false` the leading ECMA token is dropped, yielding
-    # "-411" / "TR/101" / "MEM/1970". The edition is never rendered — it is
-    # separate metadata carried only in `to_hash`.
+    # "-411" / "TR/101" / "MEM/1970".
     class Renderer < ::Pubid::Renderers::Base
       PUBLISHER = "ECMA"
 
-      def render(context: nil, **opts)
+      # `with_edition` and `with_volume` default to TRUE — the inverse of
+      # pubid's usual opt-in, deliberately. `Relaton::Index::Type#add_or_update`
+      # keys on a BARE `id.to_s` and cannot pass options, so the default
+      # rendering is what the index keys on, and it has to be unique per row.
+      # With the edition omitted, all 22 editions of ECMA-74 collapsed onto one
+      # key and 383 of the 804 published rows were dropped silently.
+      #
+      # Per-flavor divergence in these defaults is the established pattern:
+      # Pubid::Tgpp defaults `with_publisher` to false and Pubid::W3c to true,
+      # each for its own consumer's reason.
+      def render(context: nil, with_edition: true, with_volume: true, **_opts)
         id = @id
         # Standard joins the publisher directly ("ECMA-411"); TR/MEM separate it
         # with a space ("ECMA TR/101"). type_prefix is nil only for standards.
         sep = id.type_prefix.nil? ? "" : " "
         core = id.type_prefix.nil? ? standard_core(id) : typed_core(id)
-        with_publisher?(id) ? "#{PUBLISHER}#{sep}#{core}" : core
+        result = with_publisher?(id) ? "#{PUBLISHER}#{sep}#{core}" : core
+        result + suffixes(id, with_edition, with_volume)
       end
 
       private
 
+      # " ed<edition>" then " vol<volume>", each only when the identifier
+      # carries it and the caller has not opted out. The order is canonical:
+      # the grammar accepts the volume only after the edition.
+      def suffixes(id, with_edition, with_volume)
+        out = +""
+        out << " ed#{id.edition}" if with_edition && id.edition
+        out << " vol#{id.volume}" if with_volume && id.volume
+        out
+      end
+
       # Standard: "-<number>[-<part>]".
       def standard_core(id)
         core = "-#{id.number}"

data/lib/pubid/ecma/urn_generator.rb

@@ -2,23 +2,44 @@
 
 module Pubid
   module Ecma
-    # Emits `urn:ecma:<tag>:<number>[:part-<part>]` where the tag is bare for
-    # standards, "tr" for technical reports and "mem" for mementos:
-    #   ECMA-411      -> urn:ecma:411
-    #   ECMA-418-1    -> urn:ecma:418:part-1
-    #   ECMA TR/101   -> urn:ecma:tr:101
-    #   ECMA MEM/1970 -> urn:ecma:mem:1970
+    # Emits
+    # `urn:ecma:<tag>:<number>[:part-<part>][:ed-<edition>][:vol-<volume>]`,
+    # where the tag is bare for standards, "tr" for technical reports and "mem"
+    # for mementos:
+    #   ECMA-411          -> urn:ecma:411
+    #   ECMA-418-1        -> urn:ecma:418:part-1
+    #   ECMA TR/101       -> urn:ecma:tr:101
+    #   ECMA MEM/1970     -> urn:ecma:mem:1970
+    #   ECMA-269 ed3 vol2 -> urn:ecma:269:ed-3:vol-2
+    #   ECMA-402 ed5.1    -> urn:ecma:402:ed-5.1
+    #
+    # The edition and volume segments are additive: they only ever split a
+    # collision, so a URN minted before they existed still reads back (UrnParser
+    # probes for the labelled prefix). They are needed because edition and
+    # volume are identity-bearing — without them 804 published documents share
+    # 421 URNs.
+    #
+    # The dot of a decimal edition is KEPT: "." is `unreserved` in RFC 8141, and
+    # the URN has an inverse, so it must be lossless. (The MR string, which has
+    # no inverse, collapses it to "ed5-1" instead.)
     class UrnGenerator < Pubid::UrnGenerator::Base
       def generate
-        parts = ["urn", "ecma"]
-
-        tag = identifier.type_prefix&.downcase
-        parts << tag if tag
+        parts = ["urn", "ecma", identifier.type_prefix&.downcase,
+                 identifier.number.to_s]
+        parts.concat(labelled_segments)
+        parts.compact.join(":")
+      end
 
-        parts << identifier.number.to_s
-        parts << "part-#{identifier.part}" if identifier.part
+      private
 
-        parts.join(":")
+      # Every optional field carries its own label, so a URN written before a
+      # given label existed still reads back (UrnParser probes for the prefix).
+      def labelled_segments
+        {
+          "part" => identifier.part,
+          "ed" => identifier.edition,
+          "vol" => identifier.volume,
+        }.filter_map { |label, value| "#{label}-#{value}" if value }
       end
     end
   end

data/lib/pubid/ecma/urn_parser.rb

@@ -5,30 +5,46 @@ module Pubid
     # Parses ECMA URNs back into identifiers, inverting {UrnGenerator}.
     #
     # Examples:
-    #   urn:ecma:411        -> ECMA-411
-    #   urn:ecma:418:part-1 -> ECMA-418-1
-    #   urn:ecma:tr:101     -> ECMA TR/101
-    #   urn:ecma:mem:1970   -> ECMA MEM/1970
+    #   urn:ecma:411            -> ECMA-411
+    #   urn:ecma:418:part-1     -> ECMA-418-1
+    #   urn:ecma:tr:101         -> ECMA TR/101
+    #   urn:ecma:mem:1970       -> ECMA MEM/1970
+    #   urn:ecma:269:ed-3:vol-2 -> ECMA-269 ed3 vol2
+    #
+    # Every trailing segment is consumed only if it carries its own label, so a
+    # URN written before the edition and volume segments existed still reads
+    # back with both nil.
     class UrnParser < Pubid::UrnParser::Base
       def parse_urn(urn)
         parts = split_parts(strip_namespace(urn))
         tag = %w[tr mem].include?(parts.first) ? parts.shift : nil
         number = parts.shift
-        part = if parts.first&.start_with?("part-")
-                 parts.shift.sub("part-", "")
-               end
-        flavor_parse(reconstruct(tag, number, part))
+        part = shift_labelled(parts, "part-")
+        edition = shift_labelled(parts, "ed-")
+        volume = shift_labelled(parts, "vol-")
+        flavor_parse(reconstruct(tag, number, part, edition, volume))
       end
 
       private
 
+      # Consume the next segment only if it carries `label`. `delete_prefix`,
+      # not `sub`, so a label-shaped substring later in the value is untouched.
+      def shift_labelled(parts, label)
+        return nil unless parts.first&.start_with?(label)
+
+        parts.shift.delete_prefix(label)
+      end
+
       # Rebuild the printed identifier string from the URN fields.
-      def reconstruct(tag, number, part)
-        case tag
-        when "tr" then "ECMA TR/#{number}"
-        when "mem" then "ECMA MEM/#{number}"
-        else part ? "ECMA-#{number}-#{part}" : "ECMA-#{number}"
-        end
+      def reconstruct(tag, number, part, edition, volume)
+        base = case tag
+               when "tr" then "ECMA TR/#{number}"
+               when "mem" then "ECMA MEM/#{number}"
+               else part ? "ECMA-#{number}-#{part}" : "ECMA-#{number}"
+               end
+        base += " ed#{edition}" if edition
+        base += " vol#{volume}" if volume
+        base
       end
     end
   end

data/lib/pubid/ecma.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Ecma
     extend Pubid::PrefixesSupport

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,
         )

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

@@ -9,12 +9,20 @@ module Pubid
       # 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)
       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
@@ -32,27 +40,33 @@ module Pubid
           date == other.date
       end
 
-      private
-
-      # ETSI keeps the number and part together inside one Code component
-      # (unlike ISO's separate `part` attribute), so a top-level exclude(:part)
-      # can't reach the part. Handle it during the nested-exclusion pass: when
-      # :part/:parts is excluded, return a copy of the Code with its parts
-      # cleared while keeping the number/minor. This propagates into supplement
-      # wrappers too, because the base #exclude recurses through here with the
-      # original args. It lets a part-less reference match all parts via
-      # matches?(ignore: [..., :part]).
-      def exclude_from_nested(value, args)
+      # 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 value.is_a?(Pubid::Etsi::Components::Code) && !part_keys.empty?
-          return Pubid::Etsi::Components::Code.new(
-            number: value.number,
-            minor: value.minor,
-            parts: [],
-          )
+        if !part_keys.empty? && result.respond_to?(:parts=)
+          result.parts = []
         end
-
-        super
+        result
       end
     end