pubid 2.0.0.pre.alpha.12 → 2.0.0.pre.alpha.14

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,10 +29,15 @@ 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
 
-      parsed = parser.parse(identifier)
+      parsed = Pubid::Parg::Backend.parse(:oiml, identifier)
       builder.build(parsed)
     end
 

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/omg/identifier.rb

@@ -53,7 +53,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(identifier)
+        parsed = Pubid::Parg::Backend.parse(:omg, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/parg/artifact.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "parsanol"
+
+module Pubid
+  module Parg
+    # A baked, checksum-verified PG artifact for one flavor. The artifact
+    # is the parser of record for the flavor: its grammar, tests, entries,
+    # and embedded tables travel together and are verified on load.
+    class Artifact
+      DATA_DIR = File.expand_path("../../../data/parg", __dir__)
+      # The deferred entity atoms resolve from_table references at parse
+      # time from this dir, so the table YAMLs vendor alongside the
+      # baked artifacts.
+      TABLES_DIR = File.join(DATA_DIR, "tables")
+
+      @artifacts = {}
+
+      class << self
+        # Load and memoize the artifact for a flavor (e.g. :iso).
+        def for(flavor)
+          @artifacts[flavor] ||=
+            begin
+              path = File.join(DATA_DIR, "#{flavor}.json")
+              new(Parsanol::PARG::Artifact.load(path, tables_dir: TABLES_DIR))
+            rescue Parsanol::PARG::Error => e
+              raise Pubid::Errors::ParseError,
+                    "PG artifact #{path} rejected: #{e.message}"
+            end
+        end
+      end
+
+      def initialize(artifact)
+        @artifact = artifact
+      end
+
+      def parse(entry, input)
+        @artifact.parse(entry, input)
+      end
+
+      def checksum
+        @artifact.envelope["checksum"]
+      end
+    end
+  end
+end

data/lib/pubid/parg/backend.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parg
+    # The PG-artifact parse backend: runs the flavor's baked artifact on
+    # an input and returns the builder-ready attribute hash the flavor's
+    # Builder expects — the same hash its parslet parser produced.
+    module Backend
+      LEAF_KEYS = %i[value line column offset length].freeze
+
+      module_function
+
+      ALL_PARTS_SUFFIX = "(all parts)"
+
+      def parse(flavor, input, entry: "identifier", merge_top_sequence: true)
+        # The parslet grammar base strips the "(all parts)" suffix before
+        # parsing and marks the tree (Grammar#parse / #mark_all_parts);
+        # the artifact backend carries the same contract so every flavor
+        # whose grammar does not itself consume the suffix keeps working.
+        if input.end_with?(ALL_PARTS_SUFFIX)
+          base = input.sub(/\s*\(all parts\)\s*\z/, "")
+          tree = to_builder_hash(Artifact.for(flavor).parse(entry, base), merge: merge_top_sequence)
+          return mark_all_parts(tree)
+        end
+
+        to_builder_hash(Artifact.for(flavor).parse(entry, input), merge: merge_top_sequence)
+      rescue Parsanol::ParseFailed => e
+        raise Pubid::Errors::ParseError.new(e.message, nil,
+                                            input: input,
+                                            flavor: registered_name(flavor))
+      end
+
+      # The registered flavor name (Registry-resolvable; "3gpp" for
+      # Pubid::Tgpp), falling back to the internal symbol when the
+      # flavor is not registered.
+      def registered_name(flavor)
+        mod = Pubid.const_get(flavor.to_s.split("_").map(&:capitalize).join)
+        names = Pubid::Registry.flavor_names.select { |name| Pubid::Registry.get(name) == mod }
+        # A module may register under several names; the longest is the
+        # canonical one ("cen_cenelec", not the "cen" alias).
+        names.max_by(&:length)
+      rescue NameError
+        nil
+      end || flavor.to_s
+
+      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
+
+      # The artifact emits the parsanol-tree wire shape: capture leaves
+      # ({value, line, column, offset, length}) carry their text, and the
+      # top-level sequence is a list of capture hashes. The builder-ready
+      # form scalarizes leaves and folds that top-level list into one
+      # attribute hash (last key wins) — parslet's sequence fold.
+      def to_builder_hash(shape, merge: true)
+        normalized = normalize(shape)
+        return normalized.reduce(:merge) if merge && mergeable_sequence?(normalized)
+
+        normalized
+      end
+
+      def normalize(node)
+        case node
+        when Parsanol::Slice then node.content
+        when Hash then normalize_hash(node)
+        when Array then node.map { |item| normalize(item) }
+        else node
+        end
+      end
+
+      def normalize_hash(node)
+        return node[:value] if wire_leaf?(node)
+
+        node.transform_values { |value| normalize(value) }
+      end
+
+      def mergeable_sequence?(value)
+        value.is_a?(Array) && value.all?(Hash)
+      end
+
+      def wire_leaf?(node)
+        return false unless node.size == LEAF_KEYS.size
+
+        LEAF_KEYS.all? { |key| node.key?(key) }
+      end
+    end
+  end
+end

data/lib/pubid/parg.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parg
+    autoload :Artifact, "pubid/parg/artifact"
+    autoload :Backend, "pubid/parg/backend"
+  end
+end

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/pg.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Pg
+    autoload :Artifact, "pubid/pg/artifact"
+    autoload :Backend, "pubid/pg/backend"
+  end
+end

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/plateau.rb

@@ -31,8 +31,7 @@ module Pubid
 
       # Apply legacy update_codes normalization first
       normalized = Core::UpdateCodes.apply(input, :plateau)
-      parser = Parser.new
-      parsed = parser.parse(normalized)
+      parsed = Pubid::Parg::Backend.parse(:plateau, normalized)
       Builder.build(parsed)
     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?

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

@@ -16,7 +16,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(input)
+        parsed = Pubid::Parg::Backend.parse(:sae, input)
         Builder.build(parsed)
       end