pubid 2.0.0.pre.alpha.12 → 2.0.0.pre.alpha.13

data/lib/pubid/oiml/identifiers/annex.rb

@@ -15,6 +15,10 @@ module Pubid
           map "year_on_base", to: :year_on_base
         end
 
+        # A nil `letter` means the plural "Annexes" reference, not "any
+        # annex": it must not match a candidate naming a specific one.
+        subset_strict :letter
+
         def supplement_type
           letter ? "Annex #{letter}" : "Annexes"
         end

data/lib/pubid/oiml/identifiers/certification_system.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      # OIML-CS certification-system documents ("OIML-CS PD-05 Edition 6").
+      # The number keeps its printed zero padding ("05"); family is the
+      # PD/OD/CID document class; the print states "Edition N" instead of a
+      # year, and may carry a parenthesized trailing amendment.
+      class CertificationSystem < SingleIdentifier
+        attribute :number, :string
+        attribute :family, :string
+        attribute :amendment, :string
+        # "PD 05" prints space-separated where "PD-05" is dash-joined.
+        attribute :space_separator, :boolean, default: false
+
+        key_value do
+          map "number", to: :number
+          map "family", to: :family
+          map "amendment", to: :amendment
+          map "space_separator", to: :space_separator
+        end
+
+        def self.subset_ignored_attributes
+          super + [:space_separator]
+        end
+
+        def type_string
+          "CS"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/code_number.rb

@@ -34,6 +34,7 @@ module Pubid
         def self.included(base)
           install_attributes(base)
           install_mappings(base)
+          install_subset_rules(base)
         end
 
         def self.install_attributes(base)
@@ -53,6 +54,13 @@ module Pubid
           base.attribute :space_suffix, :boolean, default: -> { false }
         end
 
+        # A nil `part`, `subpart` or `suffix` means the document has none of
+        # them: `OIML R 138` is not `OIML R 138-Amend`, which is its
+        # amendment. Declared on each leaf, beside the columns it governs.
+        def self.install_subset_rules(base)
+          base.subset_strict :part, :subpart, :suffix
+        end
+
         # Merged by lutaml with the block SingleIdentifier declares, which
         # carries publisher/year/edition/stage/iteration.
         def self.install_mappings(base)

data/lib/pubid/oiml/identifiers/dual_published.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      # OIML sometimes co-publishes a document jointly with another SDO
+      # (ISO confirmed so far, per pubid issue #437). The printed reference
+      # carries both identifiers, joined by a bare "|":
+      #
+      #   ISO 4064-1:2024|OIML R 49-1:2024
+      #
+      # A sibling of SingleIdentifier/SupplementIdentifier — like
+      # SupplementIdentifier, it inherits NOTHING from SingleIdentifier and
+      # must delegate every identity-bearing reader (code/type/stage/
+      # iteration/publisher, the mr_* MR-slug hooks, #root) itself. Without
+      # the mr_* delegations, #to_mr_string would silently come out "" (the
+      # same filename-collision gap already documented for
+      # Amendment/Errata/Annex in lib/pubid/oiml/CLAUDE.md) — this class closes
+      # that gap from day one instead of repeating it.
+      #
+      # `first`/`second` hold the two sides in their original left-to-right
+      # print order, each a real, independently-typed `::Pubid::Identifier`
+      # (never an attr_accessor — see IEEE's CsaDualPublished for the bug
+      # that pattern causes: to_hash/from_hash/#exclude silently drop it).
+      # Either side may be OIML; `#oiml_identifier`/`#external_identifier`
+      # pick the OIML-typed one out of the pair regardless of order.
+      class DualPublished < Identifier
+        attribute :first, ::Pubid::Identifier, polymorphic: true
+        attribute :second, ::Pubid::Identifier, polymorphic: true
+
+        # Declared locally (rather than left to the inherited default)
+        # because Oiml::Identifier's shared key_value block maps "language"
+        # and "parsed_format" to real attributes — without a local
+        # declaration here, to_hash/from_hash would call a getter/setter
+        # this class never defines. Mirrors SingleIdentifier/
+        # SupplementIdentifier, which do the same for the same reason.
+        attribute :language, :string
+        attribute :parsed_format, :string, default: -> { "short" }
+
+        key_value do
+          map "first", with: { to: :first_to_kv, from: :first_from_kv }
+          map "second", with: { to: :second_to_kv, from: :second_from_kv }
+        end
+
+        # Either side may belong to any flavor, so (de)serialization goes
+        # through the generic top-level Pubid.from_hash/#to_hash, not the
+        # OIML-scoped Identifier.from_hash (which only resolves OIML types).
+        def first_to_kv(model, doc)
+          value = model.first
+          return unless value
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new("first", value.to_hash),
+          )
+        end
+
+        def first_from_kv(model, value)
+          model.first = ::Pubid.from_hash(value) if value
+        end
+
+        def second_to_kv(model, doc)
+          value = model.second
+          return unless value
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new("second", value.to_hash),
+          )
+        end
+
+        def second_from_kv(model, value)
+          model.second = ::Pubid.from_hash(value) if value
+        end
+
+        # The member that belongs to THIS flavor, wherever print order put
+        # it. relaton-index sorts on this side's root.number.
+        def oiml_identifier
+          [first, second].find { |member| member.is_a?(Oiml::Identifier) }
+        end
+
+        # The other SDO's identifier for the same document.
+        def external_identifier
+          [first, second].find { |member| !member.is_a?(Oiml::Identifier) }
+        end
+
+        def root
+          oiml_identifier ? oiml_identifier.root : self
+        end
+
+        def code
+          oiml_identifier&.code
+        end
+
+        def type
+          oiml_identifier&.type
+        end
+
+        def stage
+          oiml_identifier&.stage
+        end
+
+        def iteration
+          oiml_identifier&.iteration
+        end
+
+        def publisher
+          oiml_identifier&.publisher
+        end
+
+        def mr_publisher
+          oiml_identifier&.mr_publisher
+        end
+
+        def mr_type
+          oiml_identifier&.mr_type
+        end
+
+        def mr_number_with_part
+          oiml_identifier&.mr_number_with_part
+        end
+
+        def mr_year
+          oiml_identifier&.mr_year
+        end
+
+        # Splits `identifier` on "|" and, if it looks like an OIML dual-
+        # published reference (exactly two non-empty sides, exactly one of
+        # which starts with an OIML prefix), parses each side through its
+        # own flavor and returns the wrapper. Returns nil for anything else,
+        # so the caller (Pubid::Oiml.parse) falls through to the ordinary
+        # grammar, which raises the standard Parslet::ParseFailed for a
+        # string containing "|" (the grammar defines no rule for it).
+        def self.build(identifier)
+          sides = split_sides(identifier)
+          return nil unless sides
+
+          left, right = parse_sides(*sides)
+          return nil unless left && right
+
+          new(first: left, second: right)
+        end
+
+        # Two non-empty, stripped sides, or nil if `identifier` isn't
+        # shaped like "A|B".
+        def self.split_sides(identifier)
+          parts = identifier.split("|").map(&:strip)
+          return nil unless parts.length == 2
+          return nil if parts.any?(&:empty?)
+
+          parts
+        end
+        private_class_method :split_sides
+
+        # Parses each side through its own flavor, provided exactly one side
+        # looks like OIML (by prefix, not position). [nil, nil] otherwise.
+        def self.parse_sides(left, right)
+          left_is_oiml = Oiml::PREFIXES.any? { |p| left.start_with?(p) }
+          right_is_oiml = Oiml::PREFIXES.any? { |p| right.start_with?(p) }
+          return [nil, nil] if left_is_oiml == right_is_oiml
+
+          [parse_side(left, oiml: left_is_oiml),
+           parse_side(right, oiml: right_is_oiml)]
+        end
+        private_class_method :parse_sides
+
+        def self.parse_side(str, oiml:)
+          oiml ? Oiml.parse(str) : ::Pubid.parse(str)
+        rescue Parslet::ParseFailed, Pubid::Errors::InvalidInputError
+          nil
+        end
+        private_class_method :parse_side
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers.rb

@@ -7,8 +7,10 @@ module Pubid
       autoload :Annex, "#{__dir__}/identifiers/annex"
       autoload :BasicPublication, "#{__dir__}/identifiers/basic_publication"
       autoload :Bulletin, "#{__dir__}/identifiers/bulletin"
+      autoload :CertificationSystem, "#{__dir__}/identifiers/certification_system"
       autoload :CodeNumber, "#{__dir__}/identifiers/code_number"
       autoload :Document, "#{__dir__}/identifiers/document"
+      autoload :DualPublished, "#{__dir__}/identifiers/dual_published"
       autoload :Errata, "#{__dir__}/identifiers/errata"
       autoload :ExpertReport, "#{__dir__}/identifiers/expert_report"
       autoload :Guide, "#{__dir__}/identifiers/guide"

data/lib/pubid/oiml/parser.rb

@@ -20,14 +20,17 @@ module Pubid
       rule(:identifier) do
         amendment_identifier | amendment_short | annex_letter_identifier |
           annex_identifier | plus_supplement_identifier |
-          trailing_supplement_identifier | bulletin_identifier | base
+          trailing_supplement_identifier | cs_identifier |
+          bulletin_identifier | base
       end
 
       # Publisher - always "OIML"
       rule(:publisher) { str("OIML").as(:publisher) >> space }
 
-      # Document type - single letter
-      rule(:doc_type) { match("[BDEGRSVX]").as(:type) >> space }
+      # Document type - single letter. Strict family set: OIML publishes
+      # R D B G E V S documents (the estate grammar's family letters);
+      # any other letter is a rejection, not a flavor.
+      rule(:doc_type) { match("[BDEGRSV]").as(:type) >> space }
 
       # Bulletin locator — structured form. Year optionally followed by
       # 2-digit issue and 2-digit sequence:
@@ -128,7 +131,7 @@ module Pubid
       # (with optional space before year)
       rule(:date) do
         edition_portion |
-          (colon >> space.maybe >> year_digits.as(:year)) |
+          (space.maybe >> colon >> space.maybe >> year_digits.as(:year)) |
           (space.maybe >> lparen >> year_digits.as(:year) >> rparen)
       end
 
@@ -167,10 +170,22 @@ module Pubid
         match("[a-z]").repeat(2, 2) # Two letters: en, fr, etc.
       end
 
+      # Full-word language markers as OIML prints them ("(Fra)", "(Eng)"),
+      # three or more letters, any case. Kept verbatim on the identifier;
+      # the URN lowercases.
+      rule(:lang_word) do
+        match("[A-Za-z]").repeat(3)
+      end
+
       rule(:language_code) do
         (
           (lang_single >> slash >> lang_single) | # E/F
           lang_multi_oiml |                        # PO, PT, PE, SR
+          lang_word |                              # Fra, eng, rus — before
+                                                   # the letter rules: a
+                                                   # committed "F" of "(Fra)"
+                                                   # or "fr" of "(fra)" would
+                                                   # never fall through
           lang_single |                            # E, F, D, R, S, C, A, U, X
           lang_multi                               # en, fr
         ).as(:language)
@@ -216,9 +231,25 @@ module Pubid
       rule(:trailing_supplement_identifier) do
         base_without_language.as(:base) >>
           space >> (str("Amendment") | str("Errata")).as(:trailing_marker) >>
+          (space >> digits.as(:number)).maybe >>
           language_portion.maybe.as(:language)
       end
 
+      # OIML-CS certification-system documents. Two head spellings
+      # ("OIML-CS" / "OIML CS") and two family-number separators
+      # ("PD-05" / "PD 05"), an "Edition N" instead of a year, and an
+      # optional parenthesized trailing amendment - "(Amendment 1)".
+      rule(:cs_identifier) do
+        str("OIML").as(:publisher) >>
+          (dash >> str("CS") | space >> str("CS")).as(:cs_series) >> space >>
+          (str("PD") | str("OD") | str("CID")).as(:cs_family) >>
+          (dash | space).as(:cs_separator) >>
+          digits.as(:number) >>
+          space >> str("Edition") >> space >> digits.as(:edition) >>
+          (space >> lparen >> str("Amendment") >> space >>
+            digits.as(:cs_amendment) >> rparen).maybe
+      end
+
       # Plus-joined supplement - "BASE:YEAR+Supplement:YEAR" form where both
       # the base and the supplement carry their own year. Used for amendments
       # and errata to dated bases (e.g. "OIML B 10:2011+Amendment:2012").

data/lib/pubid/oiml/renderer.rb

@@ -18,10 +18,14 @@ module Pubid
         @context = context
 
         case id
+        when Identifiers::DualPublished
+          render_dual_published(id)
         when Identifiers::Annex
           render_annex(id)
         when Identifiers::Bulletin
           render_bulletin(id)
+        when Identifiers::CertificationSystem
+          render_cs(id)
         when SupplementIdentifier
           render_supplement(id)
         when SingleIdentifier
@@ -33,6 +37,16 @@ module Pubid
 
       private
 
+      # Certification-system document: "OIML-CS PD-05 Edition 6 (Amendment 1)".
+      # The family-number separator keeps the parsed spelling; OIML CS
+      # documents state an edition instead of a year.
+      def render_cs(id)
+        result = "#{id.publisher}-CS #{id.family}" \
+                 "#{id.space_separator ? ' ' : '-'}#{id.number} Edition #{id.edition}"
+        result += " (Amendment #{id.amendment})" if id.amendment
+        result
+      end
+
       # Render the Bulletin in the requested or parsed form. Default is the
       # structured "YYYY-II-SS" form (the dataset's primary docid). The
       # citation form ("LXVII(2) 20260211") is emitted when the user asks
@@ -93,6 +107,12 @@ module Pubid
         str.sub(/\s*\([^)]+\)\s*$/, "").strip
       end
 
+      # Bare "|", original left-to-right print order, e.g.
+      # "ISO 4064-1:2024|OIML R 49-1:2024".
+      def render_dual_published(id)
+        "#{id.first}|#{id.second}"
+      end
+
       def render_single(id)
         format = effective_format(id)
 
@@ -147,10 +167,12 @@ module Pubid
 
         # Trailing-word shorthand: "BASE Amendment" / "BASE Errata" with the
         # publication year kept on the base identifier. The word comes from the
-        # concrete supplement class.
+        # concrete supplement class; an ordinal, when printed ("Amendment 1"),
+        # follows it.
         if id.trailing
           base_str = strip_language(id.base.to_s)
           result = "#{base_str} #{id.supplement_type}"
+          result += " #{id.number}" if id.number
           result += " (#{id.language})" if id.language
           return result
         end

data/lib/pubid/oiml/single_identifier.rb

@@ -14,6 +14,10 @@ module Pubid
         "short"
       } # Track parsed format
 
+      # A nil `language` means the document states none: `OIML R 126:2015
+      # Errata` is not `OIML R 126:2015 Errata (E)`, its English edition.
+      subset_strict :language
+
       # Serialization delta on top of Oiml::Identifier's shared block. The
       # `date` (year) component is flattened to a top-level key rather than a
       # nested hash, mirroring ISO (lib/pubid/iso/identifier.rb). `type` is

data/lib/pubid/oiml/supplement_identifier.rb

@@ -7,8 +7,14 @@ module Pubid
       # These wrap a base identifier like ISO amendments
       attribute :base, Oiml::Identifier, polymorphic: true
       attribute :year, :string
+      # Ordinal of the trailing-word form ("OIML R 138:2009 Amendment 1").
+      attribute :number, :string
       attribute :language, :string
 
+      # A nil `language` means the document states none, mirroring
+      # SingleIdentifier's rule.
+      subset_strict :language
+
       # Delegate the document code to the wrapped standard, mirroring
       # Pubid::Etsi::Identifiers::SupplementIdentifier#code.
       #
@@ -54,6 +60,7 @@ module Pubid
         map "base",
             with: { to: :base_to_kv, from: :base_from_kv }
         map "year", to: :year
+        map "number", to: :number
         map "trailing", to: :trailing
         map "joined", to: :joined
       end

data/lib/pubid/oiml/urn_generator.rb

@@ -27,6 +27,25 @@ module Pubid
         identifier.language&.to_s&.downcase
       end
 
+      # DualPublished declares no `date` attribute of its own (it lives on
+      # whichever side is OIML), so the shared Base#urn_year — which gates
+      # on `identifier.class.attributes.key?(:date)` — would silently drop
+      # the year. Read it through the OIML side instead.
+      def urn_year
+        if identifier.is_a?(Identifiers::DualPublished)
+          oiml_date = identifier.oiml_identifier&.date
+          return oiml_date&.year&.to_s
+        end
+
+        year = super
+        return year if year
+
+        # The trailing-word form keeps the publication year on the base
+        # ("R 138:2009 Amendment 1"); the supplement itself carries only the
+        # ordinal.
+        identifier.base&.date&.year&.to_s if identifier.is_a?(SupplementIdentifier)
+      end
+
       def generate
         # Bulletin issues carry no code; the (year, issue, sequence) tuple
         # is the locator. URNs are canonical regardless of how the input was
@@ -39,6 +58,15 @@ module Pubid
           return parts.join(":")
         end
 
+        # Certification-system documents: the family-number pair is the
+        # document identity ("cs:pd-05"); the printed edition and trailing
+        # amendment are print states, not URN segments.
+        if identifier.is_a?(Identifiers::CertificationSystem)
+          parts = ["urn", "oiml", "cs",
+                   "#{identifier.family.downcase}-#{identifier.number}"]
+          return parts.join(":")
+        end
+
         parts = ["urn", "oiml"]
         parts << urn_type
         parts << urn_number if urn_number

data/lib/pubid/oiml.rb

@@ -29,6 +29,11 @@ module Pubid
         raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
+      if identifier.include?("|")
+        dual = Identifiers::DualPublished.build(identifier)
+        return dual if dual
+      end
+
       parser = Parser.new
       builder = Builder.new
 

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/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

@@ -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?