pubid 2.0.0.pre.alpha.11 → 2.0.0.pre.alpha.13

data/lib/pubid/omg/CLAUDE.md

@@ -0,0 +1,15 @@
+# OMG flavor notes
+
+OMG document parts, the separator that normalizes, the acronym charset and its slash, and the bare `beta`.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/omg/` or `spec/pubid/omg/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **The document part reuses the inherited `part`, retyped to `:string`**: an OMG identifier is `OMG <ACRONYM>[ <VERSION>][ <PART>]`, and the third component is a real OMG form, not an invention. OMG published UML 2.1.1 as **two** documents and its URLs carry the segment (`/spec/UML/2.1.1/Superstructure`, `/spec/UML/2.1.1/Infrastructure`); the same position also holds a format name (`/spec/DDS/1.4/PDF`). Both go into one optional component. The attribute is the **`part` that `::Pubid::Identifier` already declares** as a `Components::Code`, retyped to `:string` on `Pubid::Omg::Identifier` — the tranche-1 shape (ansi/api/idf/jcgm/bsi/cen_cenelec). Three things follow from reusing the inherited name rather than inventing a `document_part`: relaton gets `remove_part!` as a plain `exclude(:part)` with no OMG-specific knowledge, `Renderers::Annotator::TOKENS` already carries `[:part, "part"]` so annotation costs nothing, and there is no second, permanently-nil `part` on every identifier. The **placement** is what makes the retype safe: it sits once on `Pubid::Omg::Identifier`, which every OMG identifier inherits from and whose class body lives in one file (`lib/pubid/omg/identifier.rb`) and is never reopened — the condition the root `CLAUDE.md` states for a base-level declaration. Never move it onto `Identifiers::Specification`, and never add a second declaration there: a redeclaration moves the generated accessor's `owner`, which the retype tripwire specs of other flavors treat as a delegation.
+- **The separator normalizes, and that is a matching decision, not a cosmetic one**: OMG writes the part behind either a space or a slash, so `Parser#part_separator` is `space | str("/")` and the parser takes both. The renderer prints **only a space**, so `OMG DDS 1.4/PDF` is a *normalizing* parse rendering `OMG DDS 1.4 PDF`. The alternative — a `part_separator` sibling attribute in the CSA `year_format` shape — round-trips both spellings byte for byte but makes them **not `==`**, and `#matches?` is `exclude(*ignore) == other.exclude(*ignore)`, so a relaton index lookup between the two spellings would return nothing with no error. That is the silent failure mode the root file records as the costliest here, and it is not worth a separator. `spec/pubid/omg/identifier_spec.rb` asserts the normalization **and** the equality, so a future attempt to preserve the separator turns both red. The slash forms therefore cannot live in `spec/fixtures/omg/pass/`, whose spec demands a byte-exact round-trip; they are pinned in the identifier spec instead, with a comment in the fixture file saying why.
+- **The acronym is the URL segment, so it takes every character OMG puts there — and a slash before the version belongs to it.** A consumer (relaton) builds `https://www.omg.org/spec/<acronym>/` from the parsed acronym, so the acronym must be verbatim. The old rule `[A-Z][A-Za-z0-9]*` rejected **30 of the 270** acronyms the catalog names: 25 with a hyphen (`DDS-XTypes`, `IDL4-CPP`), 4 with a slash (`EDMC-FIBO/BE`), `VSIPL++` and the lower-case `smartant`. `Parser#acronym` now starts with any letter, takes letters, digits and `+`, and joins further non-empty segments with `-` or `/`, so a trailing hyphen or slash is never consumed. **The slash is the design decision.** The document-part bullet above made a slash separate the part, and `OMG EDMC-FIBO/BE` could then read as acronym `EDMC-FIBO` with part `BE` — which builds the URL of the wrong page, silently. The rule now is: **before the version a slash is part of the acronym, after the version it separates the part** (`OMG DDS 1.4/PDF` is unchanged; `OMG EDMC-FIBO/BE 1.1/PDF` reads both). `Parser#identifier` spells that out — a part that follows the acronym directly takes only a space. The cost is that `OMG UML/Superstructure` now reads as acronym `UML/Superstructure`; no spec, fixture or relaton corpus row used that spelling, and OMG writes the space. A fixed list of the four FIBO domains was the alternative and was rejected: it drifts when OMG adds a domain. **Known limit — a two-word title still parses.** The grammar cannot tell an acronym from a word, so `OMG Real-Time Extension` reads as acronym `Real-Time`, part `Extension`. This is not new: on `main` before this change, `OMG Model Driven` already read as acronym `Model`, part `Driven`; the wider charset only adds hyphenated and lower-case first words. A longer title (`OMG Model Driven Architecture Guide rev. 2.0`) still raises, because the grammar has no place for a third word. `spec/pubid/omg/identifier_spec.rb` carries all 30 catalog acronyms as a frozen, network-free list. To re-check against the live catalog (270 acronyms, 0 rejections on 2026-09-14): `curl -s https://www.omg.org/spec/ | ruby -e 'puts STDIN.read.scan(%r{spec/(.+?)/About-[^"]*"}).flatten.uniq'`, then `Pubid::Omg.parse("OMG #{acronym}")` for each. (hand-off: `metanorma__pubid__omg-acronym-charset`.)
+- **The bare `beta` is not optional polish — the document part makes it load-bearing.** `parser.rb` used to demand `" beta "` followed by at least one digit. Once an optional third token is legal, a PEG grammar parses `OMG UML 2.5 beta` as version `2.5` plus a **document part named `beta`** — a silent wrong answer, not a parse failure, and exactly the shape that costs nothing until a consumer compares two identifiers. So the beta number is `.maybe`, and the version rule consumes the label whole. **This is what OMG actually publishes, checked against the source**: `https://www.omg.org/spec/UML/2.5/Beta1/` gives its own version as **`2.5 beta`**, the unnumbered form, while DDS 1.4 supersedes `https://www.omg.org/spec/DDS/1.4/Beta2`. Both spellings are real. The regression guard is the example asserting that `OMG UML 2.5 beta` leaves `part` **nil**; the round-trip example alone would pass either way.
+- **Both halves of the beta label need a word boundary, and the failure mode is a rejection rather than a misparse.** Parslet never backtracks into a `.maybe` that already succeeded. With an unanchored `str(" beta")`, `OMG DDS 1.4 beta2` and `OMG DDS 1.4 betawave` made the version rule commit to `" beta"`, fail to find the beta number, and leave `2`/`wave` with no separator in front of it — so the **whole identifier raised**, not merely parsed oddly. The same trap sits behind the beta number: without a guard, `OMG UML 2.5 beta 1x` consumed `" 1"` and then choked on `x`. `Parser#beta` therefore ends each half with `word_boundary` (`match("[A-Za-z0-9]").absent?`), which costs nothing — a genuine bare `beta` is followed by the end of input or a space, and a genuine beta number by the same. All three inputs now read the tail as a document part. A code review found the first case; the second and third came out of probing the fix. The lesson generalizes to any flavor adding an optional trailing token after an optional literal-suffixed one: **anchor the literal, or the earlier rule eats the later one's first word and the identifier is rejected**.
+- **Known limit — `Beta2` reads as a document part.** OMG's URL spelling glues the label and the number and capitalizes (`.../1.4/Beta2`), so `OMG DDS 1.4 Beta2` parses as version `1.4` with the part `"Beta2"`. It round-trips and it is not wrong enough to chase: no reference in the relaton corpus uses that spelling, the version rule follows the lowercase, space-separated form the relaton regex accepted, and widening it would need a rule that tells `Beta2` from a genuine volume name. Recorded rather than fixed.
+- **`root.number` is nil for every OMG identifier, and so is the MR slug. Neither moved here, and nothing depends on either yet.** OMG models `acronym`/`version`/`part` and never sets the `number` it inherits, so the index key the root file requires of every leaf is empty and `to_mr_string` is `""` for every identifier — both were already true before this branch and both are unchanged by it (the base `mr_number_with_part` reads `number`, not `part`, so adding the part does not populate the slug). OMG has **no index and no `relaton-data-omg`** — it is scraped from `www.omg.org/spec` with Mechanize — and the relaton migration hand-off explicitly forbids adding one, so the binary-search degradation the root file describes cannot bite today. Do not "fix" it by mirroring `acronym` into `number` without checking the renderer first: that is the precondition the BIPM entry names, and the NIST attempt recorded in the root file is what happens when it does not hold.
+- **The fixture corpus is hand-written.** OMG has no `spec/fixtures/omg/identifiers/full/` tree and no entry in `spec/fixtures/classify_fixtures.rb`, so `validation:classify` never rewrites `pass/` or `fail/` and the root file's rule against hand-editing them does not apply. `spec/pubid/omg/fixtures_spec.rb` skips `#` lines, so the files carry comments.
+- **relaton note**: `relaton/relaton` moves its OMG flavor off the hand-written regex at `lib/relaton/omg/scraper.rb:19` onto this flavor. Both blockers it named are fixed. Its probe expected `OMG DDS 1.4/PDF` to round-trip byte for byte; it now sees a normalizing parse, which is harmless there because the flavor reads `acronym` and `version` off the parsed object and keeps the document part out of the request URL. (hand-offs: `metanorma__pubid__omg-document-part-and-bare-beta`, `relaton__relaton__omg-pubid-migration`.)

data/lib/pubid/omg/builder.rb

@@ -18,3 +18,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Omg::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/parser/grammar.rb

@@ -21,10 +21,22 @@ module Pubid
     # bypasses this and raises a bare `Parslet::ParseFailed`. Nothing in the
     # gem does that.
     class Grammar < ::Parslet::Parser
+      # A trailing "(all parts)" marks the reference as the whole document.
+      # The flavor grammars that carry their own rule consume it inside
+      # parslet; this shared strip gives every other flavor the same read:
+      # the suffix never reaches the flavor grammar, and the parsed tree
+      # carries :all_parts for the builder to wrap (see Builder::Base).
+      ALL_PARTS_SUFFIX = "(all parts)".freeze
+
       # @param io [String, IO]
       # @param options [Hash] passed through to parslet
       # @raise [Pubid::Errors::ParseError]
       def parse(io, options = {})
+        if io.is_a?(String) && io.end_with?(ALL_PARTS_SUFFIX)
+          base = io.sub(/\s*\(all parts\)\s*\z/, "")
+          return mark_all_parts(super(base, options))
+        end
+
         super
       rescue ::Pubid::Errors::ParseError
         # A nested grammar already wrapped it. Keep the inner flavor and input.
@@ -35,6 +47,17 @@ module Pubid
 
       private
 
+      # Carry the stripped suffix into the tree. Parslet tops are a Hash or
+      # an Array of Hashes; the marker joins either shape, and every builder
+      # (Builder::Base and the standalone ones) routes it to #to_all_parts.
+      def mark_all_parts(tree)
+        case tree
+        when Hash then tree.merge(all_parts: true)
+        when Array then tree.map { |t| t.merge(all_parts: true) }
+        else tree
+        end
+      end
+
       # @param error [Parslet::ParseFailed]
       # @param io [String, IO] what was handed to {#parse}
       # @return [Pubid::Errors::ParseError]

data/lib/pubid/plateau/builder.rb

@@ -52,3 +52,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Plateau::Builder.prepend(Pubid::Builder::AllPartsWrap)

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

@@ -14,6 +14,10 @@ module Pubid
       attribute :number, :integer
       attribute :annex, :integer, default: -> {}
 
+      # A nil `annex` means the document has none: PLATEAU Handbook #10 is
+      # not its annex, PLATEAU Handbook #10-1.
+      subset_strict :annex
+
       # Stored as a plain string (always "PLATEAU") so it round-trips through
       # to_hash/from_hash. Was a `def publisher` method, which made lutaml
       # serialize a String against the Components::Publisher attribute.

data/lib/pubid/plateau/supplement_identifier.rb

@@ -9,9 +9,16 @@ module Pubid
     class SupplementIdentifier < Pubid::Identifier
       attribute :base, Identifier
       attribute :letter, :string, default: -> {}
+      # Stored as a plain string (always "PLATEAU") so it round-trips through
+      # to_hash/from_hash. Was a `def publisher` method, which made lutaml
+      # serialize a String against the Components::Publisher attribute
+      # (pubid/pubid#407) — the same fix as Identifiers::Base.
+      attribute :publisher, :string, default: -> { "PLATEAU" }
 
-      def publisher
-        "PLATEAU"
+      # The UrnGenerator reads type_string on every identifier; the annex
+      # supplement's own type makes its "an" URN branch reachable.
+      def type_string
+        "Annex"
       end
 
       # Subclasses must implement supplement_string
@@ -22,6 +29,11 @@ module Pubid
       # Override base_hash to extract edition, type, and annex from base
       def base_hash
         hash = super
+        # The base document's number: without it from_hash cannot
+        # reconstruct the wrapped identifier (pubid/pubid#407).
+        if base.class.attributes.key?(:number) && base.number
+          hash[:number] = base.number
+        end
         # For Plateau supplements, edition comes from the base identifier
         if base.class.attributes.key?(:edition) && base.edition
           hash[:edition] = base.edition

data/lib/pubid/plateau/urn_generator.rb

@@ -20,7 +20,13 @@ module Pubid
 
         parts << format("%02d", identifier.number) if identifier.number
 
-        parts << format("%02d", identifier.annex) if identifier.annex
+        if identifier.class.attributes.key?(:annex)
+          parts << format("%02d", identifier.annex) if identifier.annex
+        # Annex supplements carry a letter, not an annex number
+        # (pubid/pubid#407).
+        elsif identifier.class.attributes.key?(:letter) && identifier.letter
+          parts << identifier.letter.to_s.downcase
+        end
 
         parts.join(":")
       end

data/lib/pubid/renderers/directives_renderer.rb

@@ -37,7 +37,9 @@ module Pubid
           abbr = annotate(abbr, typed_stage_css(@id.typed_stage), 
                           annotated: ann)
         end
-        subgroup_str = @id.subgroup.render(context:) if @id.subgroup
+        if @id.subgroup
+          subgroup_str = render_component(@id.subgroup, context)
+        end
 
         [
           pub_str,

data/lib/pubid/renderers/human_readable.rb

@@ -12,7 +12,6 @@ module Pubid
         parts << render_edition_portion(context) if with_edition
         result = parts.compact.join(" ")
         result << render_language_portion(context, with_edition: with_edition)
-        result << " (all parts)" if @id.all_parts
         result
       end
 

data/lib/pubid/sae/builder.rb

@@ -20,7 +20,7 @@ module Pubid
         when :type
           Components::Type.new(abbr: value.to_s)
         when :number
-          Components::Code.new(value: value.to_s)
+          value.to_s
         when :year
           { date: Components::Date.new(year: value.to_i) }
         else
@@ -30,3 +30,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Sae::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/sae/components/date.rb

@@ -8,6 +8,8 @@ module Pubid
       # Date component for SAE standards
       # SAE uses year only (e.g., 2024, 2022)
       class Date < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :year, :integer
 
         def present?

data/lib/pubid/sae/components/type.rb

@@ -8,6 +8,8 @@ module Pubid
       # Type component for SAE document types
       # AMS, AIR, ARP, AS, MA
       class Type < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :abbr, :string
 
         def to_s

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

@@ -22,7 +22,10 @@ module Pubid
 
       attribute :publisher, :string, default: -> { "SAE" }
       attribute :type, Sae::Components::Type
-      attribute :number, Sae::Components::Code
+      # A plain :string, like every converted flavor. Sae::Components::Code was
+      # a bare alias of the shared component and never carried more than
+      # `value`, so this is a representation change only.
+      attribute :number, :string
       attribute :date, Sae::Components::Date
 
       def self.type

data/lib/pubid/sae/urn_generator.rb

@@ -12,7 +12,7 @@ module Pubid
       def urn_number
         return nil unless identifier.number
 
-        identifier.number.render(context: URN_CONTEXT)
+        identifier.number.to_s
       end
 
       def generate

data/lib/pubid/subset_match.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Subset match: `reference === candidate`.
+  #
+  # The match is true when every part that +reference+ states matches
+  # +candidate+. A part that +reference+ leaves nil or empty is a wildcard.
+  # relaton uses it to match a partial user reference against index rows, so
+  # the caller does not have to name the parts to ignore, as `#matches?`
+  # requires.
+  #
+  #   reference = Pubid::Iso.parse("ISO 9001")
+  #   dated = Pubid::Iso.parse("ISO 9001:2015")
+  #   reference === dated # => true
+  #   dated === reference # => false
+  #
+  # The operator is NOT symmetric: the receiver is the reference. Ruby calls
+  # `===` for `case` and `Enumerable#grep`, so `catalogue.grep(reference)`
+  # returns the entries that match the reference. RSpec calls it too: the
+  # fuzzy matchers (`include`, `match`, `contain_exactly`, `have_attributes`)
+  # and mock argument matchers (`with`) try `expected === actual` when `==` is
+  # false. So an expectation with a partial identifier on the expected side
+  # passes against a fuller one. Use `eq` when a spec needs exact equality.
+  #
+  # Rules:
+  # - The two objects must be instances of the same class. A reference never
+  #   falls back to the base document of a wrapper: `BS 7273-4` does not match
+  #   `BS 7273-4:2015+A1:2021`.
+  # - A default value is stated. `ISO 9001` means the published stage, so it
+  #   does not match `ISO/DIS 9001`.
+  # - A collection matches by position, and the reference can be shorter:
+  #   `ISO/IEC 9001` matches `ISO/IEC/IEEE 9001`, `ISO/IEEE 9001` does not.
+  # - A STRICT attribute is exempt from both wildcards: the reference always
+  #   states it, so a nil value means "this document has none" and a stated
+  #   collection is not a prefix. A class declares one with `subset_strict`.
+  # - A reference that sets +all_parts+ matches every part of the document:
+  #   `part`, `parts`, `subpart` and `all_parts` itself are skipped.
+  # - A nested identifier or component that includes this module is compared
+  #   with its own `===`. Any other value is compared with `==`.
+  # - `#==` does not change. An error from an attribute reader propagates.
+  #
+  # The match walks the attributes of the objects, not their `to_hash`, so a
+  # class can change the rule for its own attributes:
+  # - `subset_strict` names attributes the reference always states, for
+  #   example an ECMA `part` or an ETSI `parts` list.
+  # - `self.subset_ignored_attributes` names attributes that `===` skips, for
+  #   example a value that `from_hash` cannot restore (NIST build artifacts).
+  # - `#subset_attribute_match?` decides one attribute; an override calls
+  #   `super` for the attributes it does not handle.
+  #
+  # Every identifier and every component class includes this module. A new
+  # component class must include it too; `spec/pubid/subset_match_spec.rb`
+  # fails otherwise.
+  module SubsetMatch
+    # The parts of a document, which a reference with +all_parts+ does not
+    # restrict. `all_parts` itself is here so that an all-parts reference
+    # matches a candidate that states one part.
+    ALL_PARTS_ATTRIBUTES = %i[part parts subpart all_parts].freeze
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class-level hooks.
+    module ClassMethods
+      # Declare attributes that the reference always states. A nil or empty
+      # value then means "this document has none", and a stated collection
+      # must match in full instead of as a prefix.
+      #
+      #   class Pubid::Ecma::Identifier < Pubid::Identifier
+      #     subset_strict :part
+      #   end
+      #
+      # A caller that does want every part of a document sets `all_parts` on
+      # the reference, or keeps using `#matches?(other, ignore:)`.
+      #
+      # @param names [Array<Symbol>] the attributes of this class
+      # @return [Array<Symbol>] the attributes this class itself declares
+      def subset_strict(*names)
+        @subset_strict_own = subset_strict_own | names.map(&:to_sym)
+      end
+
+      # @return [Array<Symbol>] the attributes that `===` compares exactly,
+      #   this class's own declarations and every one it inherits
+      def subset_strict_attributes
+        inherited = if superclass.respond_to?(:subset_strict_attributes)
+                      superclass.subset_strict_attributes
+                    else
+                      []
+                    end
+        inherited | subset_strict_own
+      end
+
+      # @return [Array<Symbol>] the attributes that `===` skips
+      def subset_ignored_attributes
+        []
+      end
+
+      private
+
+      def subset_strict_own
+        @subset_strict_own ||= []
+      end
+    end
+
+    # @param other [Object] the candidate
+    # @return [Boolean] true when +other+ holds every part that self states
+    def ===(other)
+      return true if equal?(other)
+      return false unless other.instance_of?(self.class)
+
+      ignored = subset_skipped_attributes
+      self.class.attributes.each_key.all? do |name|
+        ignored.include?(name) || subset_attribute_match?(
+          name, public_send(name), other.public_send(name)
+        )
+      end
+    end
+
+    # @return [Array<Symbol>] the attributes this match does not compare
+    def subset_skipped_attributes
+      ignored = self.class.subset_ignored_attributes
+      return ignored unless subset_all_parts_wildcard?
+
+      ignored | ALL_PARTS_ATTRIBUTES
+    end
+
+    # True when the reference asks for every part of the document.
+    # `Pubid::Identifier` overrides it to read its +all_parts+ attribute; a
+    # component never holds a document's parts.
+    # @return [Boolean]
+    def subset_all_parts_wildcard?
+      false
+    end
+
+    # @param name [Symbol] the attribute name
+    # @param mine [Object] the value of the reference
+    # @param theirs [Object] the value of the candidate
+    # @return [Boolean] true when +theirs+ satisfies +mine+
+    def subset_attribute_match?(name, mine, theirs)
+      return SubsetMatch.exact_match?(mine, theirs) if
+        self.class.subset_strict_attributes.include?(name)
+
+      SubsetMatch.value_match?(mine, theirs)
+    end
+
+    # @return [Boolean] true when +theirs+ satisfies the reference value +mine+
+    def self.value_match?(mine, theirs)
+      return true if blank?(mine)
+
+      case mine
+      when ::Array then collection_match?(mine, theirs)
+      when SubsetMatch then mine === theirs
+      else mine == theirs
+      end
+    end
+
+    # A strict attribute is compared exactly: nil and empty are the same
+    # value, so a parsed identifier still matches the index row that
+    # `from_hash` rebuilds from a hash that dropped the empty attribute; a
+    # collection must match in full, element by element.
+    #
+    # Exactness composes rather than flattening: a nested value that
+    # includes this module is matched in BOTH directions with its own
+    # `===`, so the class that owns it keeps its rule. A plain `==` would
+    # override it — `Components::TypedStage` ignores `original_abbr`
+    # (the input spelling, `Amd` against `AMD`), and CEN/CENELEC declares
+    # `typed_stage` strict.
+    # @return [Boolean]
+    def self.exact_match?(mine, theirs)
+      return true if blank?(mine) && blank?(theirs)
+
+      case mine
+      when ::Array then exact_collection_match?(mine, theirs)
+      when SubsetMatch then mine === theirs && theirs === mine
+      else mine == theirs
+      end
+    end
+
+    # A strict collection matches in full, never as a prefix.
+    def self.exact_collection_match?(mine, theirs)
+      theirs.is_a?(::Array) && mine.size == theirs.size &&
+        mine.each_with_index.all? { |value, i| exact_match?(value, theirs[i]) }
+    end
+
+    # A shorter reference collection matches the leading elements.
+    def self.collection_match?(mine, theirs)
+      theirs.is_a?(::Array) && mine.size <= theirs.size &&
+        mine.each_with_index.all? { |value, i| value_match?(value, theirs[i]) }
+    end
+
+    # @return [Boolean] true for nil and for an empty string or collection
+    def self.blank?(value)
+      value.nil? || Lutaml::Model::Utils.empty?(value)
+    end
+  end
+end

data/lib/pubid/tgpp/CLAUDE.md

@@ -0,0 +1,43 @@
+# 3GPP flavor notes
+
+3GPP (`Pubid::Tgpp`) module naming and partial references.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/tgpp/` or `spec/pubid/tgpp/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **Digit-leading flavor names (`3gpp`/`Pubid::Tgpp`)**: a relaton flavor whose name starts with a digit can't be a Ruby constant, so the module is spelled out (`Pubid::Tgpp`, files under `lib/pubid/tgpp/`) while the **external contract stays the digit form** everywhere it's observed: the registry key (`Pubid::Registry.register(:"3gpp", …)`), the polymorphic `_type` (`pubid:3gpp:…`), and the URN namespace (`urn:3gpp:…`). Three overrides bridge the gap — (1) `Identifier.polymorphic_name` post-processes the auto-derived name (`super&.sub(/\Apubid:tgpp:/, "pubid:3gpp:")`) so `_type`/`TGPP_TYPE_MAP` agree; (2) `UrnParser#flavor_name` returns `"3gpp"` so `strip_namespace` accepts `urn:3gpp:`; (3) the export layer registers `:tgpp` (NOT `:"3gpp"`) in `Export::Exporter::FLAVORS` because `FlavorExporter` maps the symbol via `Pubid.const_get(camelize(sym))`, and it reads fixtures from `spec/fixtures/tgpp/` — so this flavor's on-disk paths (`spec/pubid/tgpp/`, `spec/fixtures/tgpp/`) follow the module, not the digit name. `PREFIXES = ["3GPP"]` (the printed docidentifier is `3GPP TS …`; the parser also accepts the bare index form). Any future digit-leading flavor mirrors this split.
+
+- **3GPP partial references — both trailing qualifiers are optional**: a 3GPP identifier is `[3GPP ]<TR|TS> <NN.NNN>[suffix][-part…][:<release>][/<version>]`. The release segment was already `.maybe` (a handful of legacy records omit it, e.g. `TS 29.215/2.0.0`) but the **version was mandatory**, so the bare reference a person actually types — `3GPP TS 23.207` — failed to parse. Every one of the 88,464 published `relaton-data-3gpp` index rows carries both, so the corpus never exercised the gap; it blocks the *consumer*, which must parse a user query to search that index. The fix is the ETSI three-step pattern verbatim — parser `(str("/") >> version).maybe`, builder `data[:version]&.to_s` (never `""`, so the no-defaults `to_hash` drops it), renderer appending each qualifier only when present — plus the URN pair. `type` and `number_core` stay required, and `version` still demands three dotted digit groups, so `TS`, `TS foo`, `TS 23.207/4.0`, `TS 23.207/` and `TS 23.207:` are all still rejected. **URN decision: only TRAILING empty segments are dropped, never interior ones.** A bare reference gets the clean `urn:3gpp:ts:23.207` instead of a malformed `urn:3gpp:ts:23.207::`, while the pre-existing release-less form keeps the URN it has always published (`TS 29.215/2.0.0` → `urn:3gpp:ts:29.215::2.0.0`, an interior empty segment `UrnParser` already reads back). Generator and parser are exact inverses for all four present/absent combinations. **One guard the optionality forced**: the `release` rule is deliberately generic (`match["^/:"].repeat(1)`), so once the version became optional a mistyped separator — `TS 23.207:2.0.0` — silently parsed with the *version* misfiled as the release, where it was structurally impossible before. `release` now carries a `(version_core >> any.absent?).absent?` lookahead, rejecting a trailing segment shaped exactly like a version. It is anchored at **end of input**, so a real release still wins whenever a version follows (`TS 23.207:Release 2000/9.0.0`); the empirical warrant is that **none** of the 27 distinct releases in the 88,464 published rows contains a dot at all. **Landmine in the trailing-strip loop**: a bare `Array#any?` tests element *truthiness*, so `[nil, nil].any?` is `false` and strips nothing — the loop guard must be `until segments.empty? || !blank?(segments.last)`. **Nothing about the stored shape changed**: `attribute :version, :string` and the `key_value` map stay as they are, only `nil` becomes reachable, so no index migration follows and no relaton index needs regenerating. `number` was already a plain `:string` and already the relaton bsearch key — there is no IANA/BIPM/W3C-style `root.number` defect here. Verified over the whole published corpus: `to_s`, `to_urn` and the URN round-trip are **byte-identical on all 88,464 rows** before and after, with 0 empty `root.number`. 3GPP's `spec/pubid/partial_ref_spec.rb` entry moved from the laggard `omits: []` to `{ ref: "3GPP TS 23.207", omits: %i[release version] }`, leaving **AMCA as the only remaining laggard**. The new bare/partial forms are NORMALIZING for the `3GPP ` prefix (`3GPP TS 23.207` renders back as `TS 23.207`, since `with_publisher` defaults to false to match the relaton index id), so per the `CIPM/2005-06(REV)` precedent they live in `spec/pubid/tgpp/identifier_spec.rb`, **not** in the byte-exact `spec/fixtures/tgpp/identifiers/pass/`. **Pre-existing and out of scope:** `Pubid.parse` resolves only `:urn` and `:mr_string` inputs and raises for a human string in *every* flavor, so `Pubid.parse("3GPP TS 23.207")` does not route — consumers call `Pubid::Tgpp::Identifier.parse` (or pass `pubid_class:`) directly. (hand-off: tgpp-bare-reference-parse; consumer follow-up: relaton__relaton__3gpp-consume-index-v2.)
+
+## `all_parts_edition_keys` missed `release`
+
+`Identifier.all_parts_edition_keys` defaults to `%i[date year edition
+version]`. 3GPP's edition/version identity is split across two
+attributes: `version` is in the default list, but `release` (e.g.
+`"REL-4"`) is not, so `"3GPP TS 23.207:REL-4/4.0.0".to_all_parts` kept the
+release token and failed to match `"3GPP TS 23.207:REL-5/5.0.0"` under
+`#===`. Fixed with `Pubid::Tgpp::Identifier.all_parts_edition_keys` (`super
++ %i[release]`) — unlike OGC's `year`, nothing else 3GPP declares needs to
+come OUT of the default list, so this is a pure addition. Locked by
+`spec/pubid/tgpp/all_parts_spec.rb` and
+`spec/pubid/all_parts_edition_keys_audit_spec.rb`.
+
+## Related rule in the root file
+
+3GPP's `parts` attribute produced the rule that a `collection: true` attribute needs `initialize_empty: true`. That rule applies to every flavor, so it stays in the root `CLAUDE.md`, not here.
+
+## Subset match: strict attributes
+
+Read `docs/SUBSET_MATCH.md` first. `===` reads a nil part of the reference as
+a wildcard, which is wrong for the attributes below: the flavor models a nil
+value as "this document has none". They are declared with `subset_strict`, so
+`===` compares them exactly and a stated collection is not a prefix. A caller
+that does want every part of a document sets `all_parts` on the reference, or
+keeps `#matches?(other, ignore:)`.
+
+- **`suffix` and `parts` are strict** (`lib/pubid/tgpp/identifier.rb`).
+  `TS 29.198 === TS 29.198-04-1` and `TR 00.01 === TR 00.01U` are both
+  false. `parts` is the flavor's `collection: true, initialize_empty: true`
+  attribute, so a part-less identifier holds `[]` on both construction
+  paths and the strict comparison treats that `[]` and a nil alike — the
+  same asymmetry the `initialize_empty` note above is about, seen from the
+  matching side. relaton had two committed specs breaking on this.

data/lib/pubid/tgpp/builder.rb

@@ -39,3 +39,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Tgpp::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/tgpp/identifier.rb

@@ -27,6 +27,20 @@ module Pubid
       # Three-part version string, e.g. "2.0.0".
       attribute :version, :string
 
+      # 3GPP's edition/version identity is split across `release` and
+      # `version`. `version` is already in the default
+      # `%i[date year edition version]` list; `release` is not, so it
+      # survived without_parts untouched and leaked into an "all parts"
+      # identity built via #to_all_parts.
+      def self.all_parts_edition_keys
+        super + %i[release]
+      end
+
+      # A nil `suffix` and an empty `parts` mean the document has neither:
+      # `TS 29.198` is not `TS 29.198-04-1`, and `TR 00.01` is not
+      # `TR 00.01U`. A stated list is not a prefix either.
+      subset_strict :suffix, :parts
+
       # Polymorphic type map for lutaml::Model key_value (de)serialization.
       # Keys are the `pubid:3gpp:…` names produced by polymorphic_name (below).
       TGPP_TYPE_MAP = {

data/lib/pubid/type_resolver.rb

@@ -15,6 +15,9 @@ module Pubid
   class TypeResolver
     TYPE_PREFIX = "pubid:"
     SEGMENT_SEPARATOR = ":"
+    # Types of classes that belong to no flavor, so they carry no flavor
+    # segment. Class names are strings, so the lookup triggers the autoload.
+    SHARED_TYPES = { "pubid:all-parts" => "Pubid::AllPartsIdentifier" }.freeze
 
     class << self
       # @param type [String, nil] Polymorphic _type, e.g. "pubid:iso:technical-report".
@@ -23,6 +26,17 @@ module Pubid
       def resolve(type)
         return nil unless type.is_a?(String)
 
+        shared_class(type) || flavor_class(type)
+      end
+
+      private
+
+      def shared_class(type)
+        name = SHARED_TYPES[type]
+        name && Object.const_get(name)
+      end
+
+      def flavor_class(type)
         flavor_name = flavor_segment(type)
         return nil unless flavor_name
 
@@ -43,8 +57,6 @@ module Pubid
         nil
       end
 
-      private
-
       # The registered flavor whose module constant gives +segment+.
       # Identifier.polymorphic_name takes the segment from the module name
       # ("Pubid::CenCenelec" -> "cencenelec"), and a flavor can be registered

data/lib/pubid/un/builder.rb

@@ -40,3 +40,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Un::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.0.pre.alpha.11"
+  VERSION = "2.0.0.pre.alpha.13"
 end

data/lib/pubid/w3c/CLAUDE.md

@@ -0,0 +1,7 @@
+# W3C flavor notes
+
+W3C slug attribute and index key.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/w3c/` or `spec/pubid/w3c/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **W3C renamed its slug attribute `code` → `number` (index key)**: a W3C identifier is a flat slug plus an optional verbatim date, and the slug used to live in `attribute :code, :string` while the `number` inherited from `::Pubid::Identifier` (a `Components::Code`) was never set. `Relaton::Index::Type#candidates_by_number` sorts and bsearches every row on `id.root.number.to_s`, so all **16,336** published `relaton-data-w3c` rows shared the empty key `""` and the binary search degenerated to a linear scan — silently, with no error. The slug *is* the key, so the attribute was **renamed** rather than shadowed by a derived reader: `attribute :number, :string` on `Pubid::W3c::Identifier`, `map "number", to: :number` in the `key_value` block, and the three readers moved (`Builder#build`'s `new(number:)`, `Renderer#render`, `UrnGenerator#generate`). **`code` is dropped with no alias** — one name for one value. Serialized vocabulary is `{_type, number}` / `{_type, number, date}`; `to_s` and the URN shape (`urn:w3c:<type>:<slug>[:<date>]`) are byte-identical, verified over the whole published corpus (0 empty/mismatched keys, 0 round-trip failures, 1933 buckets — was 1). **Why the declaration sits on the shared base here, when IEEE/IETF/IANA put theirs on the leaves**: this still redefines the parent's `attribute :number, Components::Code` as `:string` on a class the 11 concrete `Identifiers::*` inherit from — the recorded landmine — but the mechanism shows the hazard is load-order, not inheritance: lutaml's `inherited` hook **deep-dups** the parent's attribute table into each subclass at class-definition time (`serialize/initialization.rb#initialize_attrs`), so a subclass holds a **snapshot**, not a live view. A base-level override is therefore safe iff every subclass body opens *after* the base body has run — and Ruby resolves the superclass constant (autoloading `w3c/identifier.rb` and running it to completion) before opening any leaf body. W3C's base is **one file, one class body, never reopened**, so this holds in every load order; the `date` override of the parent's `Components::Date` has relied on the same property since the flavor landed. IEEE is the counter-shape: its `identifier.rb` defines nothing and the class body lives in `identifiers/base.rb`, so the base is reachable through two paths and a leaf can snapshot it half-built. **Split this base across two files and the landmine comes back.** `spec/pubid/w3c/root_number_spec.rb` carries the structural tripwire (the base *and* all 11 leaves must resolve `number` to `Lutaml::Model::Type::String`) and is only meaningful under the full `bundle exec rake`. **relaton note**: there is no alias and no published W3C pubid index yet, so nothing needs migrating — but `relaton/relaton`'s in-flight migration off the hand-rolled `Relaton::W3c::PubId` must read `id.number`, and its `DataFetcher`-built index must be crawled *after* this lands or every row keys on `""` again. **Known gap, deliberately NOT fixed here and recorded as a separate hand-off (w3c-mr-string):** `to_mr_string` **raises `NoMethodError` for every dated W3C id** — the base `mr_year` calls `date.year`, but W3C's `date` is a plain `:string` (opaque digit runs of varying width; the flavor already works around this for its public `#year` reader, but not for `mr_year`), and `mr_type`/`mr_publisher` are always nil (`Builder` never sets `typed_stage`; the publisher is a constant). This is pre-existing on `main`, untouched by the rename, and is a *second* identity surface — `to_slug` is an output **filename**. Measured over the 16,336 published rows: a year-only `mr_year` gives **1,936 collisions**; the whole verbatim `date` plus BIPM-style charset sanitisation (the corpus needs `/` and `+`) gives **16,336 distinct, filename-safe slugs, 0 collisions**. (hand-off: w3c-index-number; consumer follow-up: relaton__relaton__w3c-pubid-number-rename.)

data/lib/pubid/w3c/builder.rb

@@ -53,3 +53,5 @@ module Pubid
     end
   end
 end
+
+Pubid::W3c::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/xsf/CLAUDE.md

@@ -0,0 +1,11 @@
+# XSF flavor notes
+
+XSF named documents (`XEP README`, `XEP xxxx`).
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/xsf/` or `spec/pubid/xsf/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **The XEP number is not always a number**: the whole XSF grammar is four rules, and the number used to be `match["0-9"].repeat(1)`. The XMPP extensions repository publishes two documents whose name is a word — the editor README (`xep-README.html`) and the template (`xep-xxxx.html`) — and both reach pubid as **real primary docids**, `XEP README` and `XEP xxxx`. They are rows of the published `relaton-data-xsf/index-v1.yaml`, backed by `data/xep-readme.yaml` (title "XEP Editor README") and `data/xep-xxxx.yaml` (title "XEP Template"). The digits-only rule rejected both at char 5, which cost two repositories a permanent workaround: `Relaton::Xsf::DataFetcher` carried `NON_DOCUMENTS = ["XEP README", "XEP xxxx"]` to swallow the parse failure in `add_to_index`, and `relaton-data-xsf/build_index_v1.rb` documented that its `index-v1` is deliberately **two rows longer** than `index-v2` (520 against 518) — one unparseable row makes `Relaton::Index` declare the whole file corrupt, delete it, and hand back an empty index, so the two rows could never enter v2. The grammar now admits the two names beside the digits: `(digits | special_number).as(:number)`, with `SPECIAL_NUMBERS = %w[README xxxx]` on `Pubid::Xsf::Parser`.
+- **Two literals, not a slug rule, and the exact case only.** `XEP foo`, `XEP readme`, `XEP XXXX`, `XEP xxx` and `XEP xxxxx` all still raise `Pubid::Errors::ParseError`, pinned one by one in `spec/pubid/xsf/identifier_spec.rb`. Widening the number to any alphanumeric run would have been one character shorter and would have made XSF an anything-goes flavor after its prefix — the shape `Pubid.parse` probes for with `accepts_anything?` and then refuses to use as a fallback. A case-insensitive match would have made the parse *normalizing* (`XEP readme` → `XEP README`), so `to_s` would no longer equal the input and the fixture round-trip spec would need the `!input!rendered` marker for a form the corpus does not contain.
+- **Nothing outside the parser changed, and that is the reason to store the name in `number`.** `number` is already `attribute :number, :string` on `Pubid::Xsf::Identifier` (a string to keep the zero padding), so `"README"` stores as it arrives; `Renderer#render` interpolates it, so `to_s` gives back `XEP README`; `UrnGenerator` gives `urn:xsf:xep:README` and `UrnParser` rebuilds the printed string and re-parses it, so the URN round-trip closes; `key_value` already maps `number`, so `from_hash(to_hash) == parse`; and `root.number` is non-empty, so the index key is sound for both. A separate attribute for the name would have broken every one of those.
+- **relaton note**: once this ships, `Relaton::Xsf::DataFetcher` can drop `NON_DOCUMENTS` and the rescue branch that reads it, `relaton-data-xsf` needs its `index-v2` regenerated to carry all 520 rows, and the `build_index_v1.rb` comment asserting the two-row difference is then wrong. (hand-off: `relaton__relaton__xsf-named-documents-are-parseable`.)
+- **Pre-existing gaps, untouched here.** XSF's MR slug carries no publisher segment — `Pubid::Xsf.parse("XEP 0001").to_slug == "0001"` — so it collides with any other flavor's bare-number slug; `lib/pubid/iana/CLAUDE.md` records XSF among the slug-only flavors that would surface this if `mr_string_spec` were made registry-driven. The fixture corpus is one hand-written file, `spec/fixtures/xsf/identifiers/pass/xep.txt`: XSF has no `identifiers/full/` directory and no `validation:classify` entry, so that file is edited by hand — the root `CLAUDE.md` rule against hand-editing `pass/` covers the classifier-driven flavors, which XSF is not. There is no `fail/` corpus at all.

data/lib/pubid/xsf/builder.rb

@@ -15,3 +15,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Xsf::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid.rb

@@ -143,7 +143,10 @@ module Pubid
   autoload :Parser, "pubid/parser"
   autoload :Components, "pubid/components"
   autoload :BundledIdentifier, "pubid/bundled_identifier"
+  autoload :AllParts, "pubid/all_parts"
+  autoload :AllPartsIdentifier, "pubid/all_parts_identifier"
   autoload :Identifier, "pubid/identifier"
+  autoload :SubsetMatch, "pubid/subset_match"
   autoload :IdentifierMetadata, "pubid/identifier_metadata"
   autoload :Rendering, "pubid/rendering"
   autoload :Renderers, "pubid/renderers"
@@ -486,15 +489,25 @@ module Pubid
   private_class_method :routing_table
 
   # True when +string+ starts with +prefix+ at a token boundary, so "ISO" does
-  # not claim "ISOFIX" and "BS" does not claim "BSI".
-  # @api private
+  # not claim "ISOFIX" and "BS" does not claim "BSI". A boundary is the end
+  # of the string or any non-alphanumeric character, so a registered prefix
+  # can be followed by a space ("ISO 9001") or by a slash attaching a type
+  # token ("ISO/TR 25901-1:2016").
+  #
+  # Public (not +@api private+) so a flavor's own prefix routing - GOST's
+  # foreign-adoption lookup, currently the only caller outside this file -
+  # can reuse the exact boundary rule {parse_by_prefix} uses, rather than
+  # keeping a second copy that can drift out of sync.
+  #
+  # @param string [String]
+  # @param prefix [String]
+  # @return [Boolean]
   def self.prefix_match?(string, prefix)
     return false unless string.start_with?(prefix)
 
     rest = string[prefix.length]
     rest.nil? || !/[A-Za-z0-9]/.match?(rest)
   end
-  private_class_method :prefix_match?
 
   def self.detect_flavor_from_urn(urn)
     # urn:iso:std:... → "iso"