pubid 2.0.1 → 2.0.2

data/lib/pubid/csa/parser.rb

@@ -1,382 +1,10 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Csa
-    class Parser < ::Pubid::Parser::Grammar
-      # Basic building blocks
-      rule(:space) { str(" ") }
-      rule(:dash) { str("-") }
-      rule(:slash) { str("/") }
-      rule(:colon) { str(":") }
-      rule(:comma) { str(",") }
-      rule(:dot) { str(".") }
-      rule(:ampersand) { str("&") }
-      rule(:plus) { str(" + ") }
-      rule(:digit) { match("[0-9]") }
-      rule(:digits) { digit.repeat(1) }
-      rule(:letter) { match("[A-Z]") }
-      rule(:letters) { letter.repeat(1) }
-
-      # Publisher
-      rule(:publisher) do
-        str("CSA") >> space >> (str("").as(:has_publisher) | str("0").as(:has_publisher))
-      end
-
-      # Code pattern: letter + dotted numbers (e.g., B149.1, C22.2, A123.17)
-      # Can also have dash-number-letter suffix (e.g., for NO. numbers like 60950-1A)
-      # Can have letter suffixes like HB, CIICHB, SP at the end
-      # Can have multiple dash-number sequences (e.g., C13256-1-01)
-      # NEW: Also support pure numbers with HB suffix (e.g., 15189HB)
-      # NEW: Simple letter+number codes (e.g., Z240, A220) for Series identifiers
-      rule(:code_pattern) do
-        # Pattern 1: Pure dotted numbers - e.g., 12.4, 2.15, 3.11
-        (match("[0-9]").repeat(1) >> dot >> match("[0-9]").repeat(1) >>
-         # Allow single-dash suffix for part numbers (e.g., "12.4-1")
-         # But NOT 2-digit years which are handled separately
-         (dash >> match("[0-9]").repeat(1)).repeat(0, 1) >>
-         letter.repeat(2, 6).maybe).as(:code) |
-          # Pattern 2: Pure numbers with HB suffix - e.g., 15189HB (NEW)
-          (match("[0-9]").repeat(1) >> letter.repeat(2, 6)).as(:code) |
-          # Pattern 3: Letter + numbers with dots then dashes - e.g., C22.2-144, B149.1
-          (letter >> match("[0-9]").repeat(1) >>
-           (dot >> match("[0-9]").repeat(1)).repeat >> # Dot sections first
-           # Dash sections after - allow part numbers but not 2-digit years
-           # Single digit dash = part number (e.g., "-1", "-2")
-           # 3+ digits or letter suffix = part number (e.g., "-144", "-1A")
-           # But DON'T consume 2-digit years which are matched separately
-           (dash >> (
-             (match("[0-9]") >> match("[0-9]").absent?) | # exactly 1 digit (no digit follows)
-             match("[0-9]").repeat(3) | # 3+ digits = part number (e.g., "-144")
-             (match("[0-9]").repeat(1) >> letter.repeat(1)) # digit + letter = part number (e.g., "-1A")
-           )).repeat >>
-           letter.repeat(2, 6).maybe).as(:code) | # Allow HB, CIICHB, SP, etc.
-          # Pattern 4: Simple letter + number codes - e.g., Z240, A220, B140 (for Series)
-          (letter >> match("[0-9]").repeat(1) >> dot >> match("[0-9]").repeat(1).maybe).as(:code) |
-          # Pattern 5: Letter + multi-digit number without dots/dashes - e.g., Z240, A220
-          (letter >> match("[0-9]").repeat(2)).as(:code)
-      end
-
-      # NO. notation - "Number" designation within a series (e.g., C22.2 NO. 1)
-      rule(:no_notation) do
-        space >> (str("NO.") | str("No.")).as(:no_notation) >> space
-      end
-
-      # Number after NO. - can be complex (e.g., 60601-1-9, 144.1, 1010.2.031, 1, 60601-1)
-      # Note: Single-dash patterns allowed only when first part has 3+ digits
-      # to avoid consuming year patterns like "1-04" where "-04" is the year
-      rule(:no_number) do
-        (
-          # Multi-part with dashes (e.g., 60601-1-9, 1-9-2)
-          # Requires at least 2 dashes (3+ numeric parts) to distinguish from year patterns
-          (match("[0-9]").repeat(1) >>
-           (dash >> match("[0-9]").repeat(1)).repeat(2, 10)) |
-          # Single-dash pattern (e.g., 60601-1, 60079-11) - allowed if first part has 3+ digits
-          # This prevents consuming year patterns like "1-04"
-          # CRITICAL: 2-digit suffix allowed only when first part has 5+ digits
-          # (IEC-style numbers like 60601, 60079). 3-4 digit first parts with 2-digit
-          # suffixes are year patterns (e.g., "109-17" = number 109, year 2017).
-          (match("[0-9]").repeat(5) >> dash >> match("[0-9]").repeat(1)) | # 5+ digits: any suffix
-          (match("[0-9]").repeat(3, 4) >> dash >> (
-            (match("[0-9]") >> match("[0-9]").absent?) | # exactly 1 digit (e.g., -1)
-            match("[0-9]").repeat(3) # 3+ digits (e.g., -144)
-          )) |
-          # Multi-part dotted number (e.g., 144.1, 1010.2.031, 1010.2.031.5)
-          # Can have 1-3 dots (2-4 numeric parts)
-          (match("[0-9]").repeat(1) >>
-           (dot >> match("[0-9]").repeat(1)).repeat(1, 3)) |
-          # Simple number (e.g., 1, 286)
-          match("[0-9]").repeat(1)
-        ).as(:no_number)
-      end
-
-      # Year format with optional F or M prefix
-      rule(:year_prefix) { (str("F") | str("M")).as(:year_prefix).maybe }
-      rule(:year_2digit) { digit.repeat(2, 2) }
-      rule(:year_4digit) { digit.repeat(4, 4) }
-
-      # Year with colon (modern format) - mark as colon_year
-      # Support both with prefix (:M04) and without prefix (:04)
-      rule(:colon_year) do
-        str("").as(:colon_format) >> # Mark that colon format was used
-          colon >> (
-          # With M/F prefix (e.g., :M04, :F04)
-          (year_prefix >> (year_4digit | year_2digit).as(:year)) |
-          # Without prefix (e.g., :04)
-          (year_4digit | year_2digit).as(:year)
-        )
-      end
-
-      # Year with dash (older format) - mark as dash_year
-      # Support both with prefix (-M04) and without prefix (-04)
-      rule(:dash_year) do
-        str("").as(:dash_format) >> # Mark that dash format was used
-          dash >> (
-          # With M/F prefix (e.g., -M04, -F04)
-          (year_prefix >> (year_4digit | year_2digit).as(:year)) |
-          # Without prefix (e.g., -04)
-          (year_4digit | year_2digit).as(:year)
-        )
-      end
-
-      # Reaffirmation notation - supports both 2-digit and 4-digit years
-      # Tracks original format via :reaffirmation_4digit flag
-      rule(:reaffirmation) do
-        space >> str("(R") >>
-          (year_4digit.as(:reaffirmation_4digit) | year_2digit.as(:reaffirmation_2digit)) >>
-          str(")")
-      end
-
-      # Amendment notation (e.g., /A1:15, /A2:22, /Amd 1)
-      rule(:amendment_slash) do
-        slash >>
-          (str("Amd") >> space).maybe >>
-          str("A").maybe >>
-          digits.as(:amendment_number) >>
-          (colon >> year_2digit.as(:amendment_year)).maybe
-      end
-
-      # Package keywords
-      rule(:package_keyword) do
-        str("Code") | str("Handbook") | str("Training Package") | str("Package")
-      end
-
-      # Package portion: "Code, Handbook & Training Package"
-      rule(:package_portion) do
-        space >>
-          package_keyword >>
-          (
-            (comma >> space >> package_keyword) |
-            (space >> ampersand >> space >> package_keyword)
-          ).repeat
-      end
-
-      # Series prefix: 2-3 letters before SERIES keyword (e.g., MH, RV)
-      rule(:series_prefix) do
-        letter.repeat(2, 3).as(:series_prefix)
-      end
-
-      # SERIES keyword - just the word, don't consume the delimiter
-      rule(:series_keyword) do
-        str("SERIES")
-      end
-
-      # Series identifier - SERIES as PRIMARY type (not modifier)
-      # Pattern: CSA code [PREFIX] SERIES:year
-      # Examples: CSA Z240 MH SERIES:16, CSA Z240 RV SERIES:23, CSA Z245.20 SERIES:22
-      rule(:series_identifier) do
-        publisher >>
-          # Code comes first (can be letter+number or dotted numbers)
-          (
-            code_pattern |
-            # Letter + multi-digit number for Series (e.g., Z240, A220, B139)
-            (letter >> match("[0-9]").repeat(2)).as(:code) |
-            # Dotted numeric code (e.g., 245.20)
-            (match("[0-9]").repeat(1) >> dot >> match("[0-9]").repeat(1)).as(:code)
-          ) >>
-          space >>
-          # Optional series prefix (MH, RV, etc.) before SERIES keyword
-          (series_prefix >> space).maybe >>
-          series_keyword.as(:series_type) >>
-          (colon_year | dash_year).maybe >>
-          reaffirmation.maybe
-      end
-
-      # CEC (Canadian Electrical Code) identifier
-      # Pattern: CSA C22.{2,3,4,6} NO. {number}:{year}
-      # Examples: CSA C22.2 NO. 286:23, CSA C22.3 NO. 7:20
-      # The "NO." notation is a semantic component and must be preserved
-      rule(:cec_identifier) do
-        publisher >>
-          (
-            str("C22.2") | str("C22.3") | str("C22.4") | str("C22.6")
-          ).as(:cec_part) >>
-          no_notation >>
-          no_number >>
-          (colon_year | dash_year).maybe >>
-          reaffirmation.maybe
-      end
-
-      # ISO/IEC/CISPR/CEI adopted standards pattern
-      # Examples:
-      #   CSA ISO/IEC 9594-2:21
-      #   CSA ISO/IEC TR 12785-3:15
-      #   CSA CISPR 16-1-1:18
-      #   CAN/CSA-ISO 10819:16
-      #   CAN/CSA-IEC 62443-2-4:17
-      #   CAN/CSA-CEI/IEC 61000-4-28-01
-      rule(:adoption_identifier) do
-        publisher.as(:adoption_pub) >>
-          (
-            # Option 1: ISO/IEC with TR/TS
-            (str("ISO/IEC").as(:adoption_org) >> space >>
-             (str("TR") | str("TS")).as(:iso_type) >> space >>
-             match("[0-9-]").repeat(1).as(:adoption_number)) |
-            # Option 1a: ISO/IEC without TR/TS (must come after TR/TS option in priority)
-            (str("ISO/IEC").as(:adoption_org_with_type) >> space >>
-             match("[0-9-]").repeat(1).as(:adoption_number)) |
-            # Option 2: ISO alone
-            (str("ISO").as(:adoption_org) >> space >>
-             match("[0-9-]").repeat(1).as(:adoption_number)) |
-            # Option 3: IEC alone
-            (str("IEC").as(:adoption_org) >> space >>
-             match("[0-9-]").repeat(1).as(:adoption_number)) |
-            # Option 4: CEI/IEC (French name for IEC)
-            (str("CEI/IEC").as(:adoption_org) >> space >>
-             match("[0-9-]").repeat(1).as(:adoption_number)) |
-            # Option 5: CISPR
-            (str("CISPR").as(:adoption_org) >> space >>
-             match("[0-9-]").repeat(1).as(:adoption_number))
-          ) >>
-          (colon | dash).as(:adoption_year_sep) >>
-          (year_4digit | year_2digit).as(:adoption_year) >>
-          (
-            # Amendment with year: /A1:22 or /A1-22
-            slash >> str("A") >> digit.as(:adoption_amendment) >>
-             (colon | dash) >> (year_4digit | year_2digit).as(:adoption_amendment_year)
-          ).maybe >>
-          reaffirmation.maybe
-      end
-
-      # Legacy: ISO/IEC TR/TS only pattern (for backward compatibility)
-      rule(:iso_iec_adoption) do
-        adoption_identifier
-      end
-
-      # Basic CSA identifier
-      rule(:csa_code) do
-        publisher >>
-          code_pattern >>
-          (
-            # Option 1: NO. notation (e.g., C22.2 NO. 1:20)
-            (no_notation >> no_number >> (colon_year | dash_year)) |
-            # Option 2: series with prefix (space + prefix + space + keyword + year)
-            (space >> series_prefix >> space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
-            # Option 3: series without prefix (space + keyword + year)
-            (space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
-            # Option 4: just year (no series, no NO.)
-            (colon_year | dash_year)
-          ).maybe >> # trailing year optional (partial reference)
-          amendment_slash.maybe # Add amendment support here
-      end
-
-      # Base CSA code without amendment (for combined identifiers)
-      rule(:base_csa_code) do
-        publisher >>
-          code_pattern >>
-          (
-            # Option 1: NO. notation
-            (no_notation >> no_number >> (colon_year | dash_year)) |
-            # Option 2: series with prefix
-            (space >> series_prefix >> space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
-            # Option 3: series without prefix
-            (space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
-            # Option 4: just year
-            (colon_year | dash_year)
-          ).maybe # trailing year optional (partial reference)
-      end
-
-      # Continuation code (optional CSA publisher prefix, for combined identifiers)
-      rule(:continuation_code) do
-        publisher.as(:has_publisher).maybe >>
-          code_pattern >>
-          (
-            # Option 1: NO. notation
-            (no_notation >> no_number >> (colon_year | dash_year)) |
-            # Option 2: series with prefix
-            (space >> series_prefix >> space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
-            # Option 3: series without prefix
-            (space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
-            # Option 4: just year
-            (colon_year | dash_year)
-          ).maybe >> # trailing year optional (partial reference)
-          amendment_slash.maybe
-      end
-
-      # Bundled portion - code that follows + (base is implied, no CSA prefix)
-      # Example: "A2:22" in "CSA C22.2 NO. 60601-1:14 + A2:22"
-      rule(:bundled_portion) do
-        code_pattern >>
-          (
-            # Option 1: NO. notation
-            (no_notation >> no_number >> (colon_year | dash_year).maybe) |
-            # Option 2: just year or no year
-            (colon_year | dash_year).maybe
-          )
-      end
-
-      # Bundled identifier with + notation (consolidated documents)
-      rule(:bundled_identifier) do
-        csa_code.as(:base) >>
-          plus >>
-          bundled_portion.as(:bundled_first) >>
-          (plus >> bundled_portion).repeat.as(:bundled_rest) >>
-          reaffirmation.maybe
-      end
-
-      # Combined CSA standards with slash
-      rule(:combined_slash) do
-        base_csa_code.as(:first) >>
-          slash >>
-          continuation_code.as(:second) >>
-          (slash >> continuation_code.as(:third)).maybe >>
-          reaffirmation.maybe >>
-          package_portion.maybe
-      end
-
-      # Combined with comma (CSA B149.1:25, CSA B149.2:25)
-      rule(:combined_comma) do
-        csa_code.as(:first) >>
-          comma >> space >>
-          csa_code.as(:second) >>
-          reaffirmation.maybe >>
-          (
-            (space >> ampersand >> package_portion) |
-            package_portion
-          ).as(:package_portion).maybe >>
-          str("").as(:comma_separator) # Mark as comma-based
-      end
-
-      # Single identifier with optional package
-      rule(:single_identifier) do
-        csa_code >> reaffirmation.maybe >> package_portion.as(:package_portion).maybe
-      end
-
-      # Code-only identifier (no CSA prefix) - try this last
-      rule(:code_only_identifier) do
-        code_pattern >>
-          (
-            # Option 1: series with prefix
-            (space >> series_prefix >> space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
-            # Option 2: series without prefix
-            (space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
-            # Option 3: just year
-            (colon_year | dash_year)
-          ).maybe >> # trailing year optional (partial reference)
-          (space >> str("PACKAGE")).as(:package_portion).maybe
-      end
-
-      # Main identifier
-      rule(:identifier) do
-        iso_iec_adoption | series_identifier | cec_identifier | bundled_identifier | combined_slash | combined_comma | single_identifier | code_only_identifier
-      end
-
-      root(:identifier)
-
-      # Preprocessing to normalize input
-      def parse(input)
-        prefix = self.class.publisher_prefix_for(input)
-        result = super(self.class.normalize_input(input))
-        if prefix && result.is_a?(Hash)
-          self.class.inject_publisher_prefix(result, prefix)
-        end
-        result
-      end
-
-      # Pre-parse ingestion normalizations (R2): every parse path —
-      # parslet and PG artifact alike — feeds the grammar the same
-      # normalized string.
+    class Parser
+      # Pre-parse ingestion normalizations (R2): every parse path feeds
+      # the grammar the same normalized string.
       def self.normalize_input(input)
         # Skip comment lines
         if input.strip.start_with?("#")
@@ -435,30 +63,21 @@ module Pubid
       private
 
       def self.inject_publisher_prefix(hash, prefix)
-        # For combined identifiers
-        if hash[:first]
-          hash[:first][:publisher_prefix] = prefix
-        end
-        # For combined_comma (has comma_separator), both first and second are full csa_code
-        # For combined_slash (no comma_separator), second is continuation that may have has_publisher
-        if hash[:second] && (hash[:comma_separator] || hash[:second][:has_publisher])
-          hash[:second][:publisher_prefix] = prefix
-        end
-        if hash[:third] && hash[:third][:has_publisher]
-          hash[:third][:publisher_prefix] =
-            prefix
-        end
-
-        # For bundled identifiers
-        if hash[:base]
-          inject_publisher_prefix(hash[:base], prefix)
-        end
-
-        # For single identifiers (no :first, no :base, just raw attributes)
-        if !hash[:first] && !hash[:base] && !hash[:bundled_first]
-          hash[:publisher_prefix] = prefix
+        # Combined and bundled identifiers carry their parts under the
+        # csa_code_part[] group; the first part always takes the prefix,
+        # later ones only when they spell their own publisher token (a
+        # slash continuation like "CSA X/60601-1-6" does not).
+        if (parts = hash[:csa_code_part])
+          parts.each_with_index do |part, index|
+            next if index.positive? && !part[:part_has_publisher] &&
+                    !hash[:comma_separator]
+
+            part[:publisher_prefix] = prefix
+          end
+          return hash
         end
 
+        hash[:publisher_prefix] = prefix
         hash
       end
     end

data/lib/pubid/doi/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Doi
-    # Parslet grammar for Digital Object Identifiers per ISO 26324.
+    # Grammar for Digital Object Identifiers per ISO 26324.
     #
     # Accepts:
     #   [doi:|DOI:]10.{REGISTRAR}/{SUFFIX}
@@ -13,40 +11,7 @@ module Pubid
     # SUFFIX is one-or-more chars from [A-Za-z0-9._\-/()] (printable minus
     # whitespace). The grammar is intentionally permissive on suffix chars
     # because real DOIs cover the full printable range.
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:dot)   { str(".") }
-      rule(:slash) { str("/") }
-
-      # Optional URL resolver prefix.
-      rule(:url_prefix) { (str("https://") | str("http://")).maybe >> str("doi.org").maybe }
-
-      # Optional DOI scheme prefix.
-      rule(:scheme_prefix) do
-        (str("doi:") | str("DOI:") | str("Doi:")).maybe
-      end
-
-      # Prefix: "10." then 2+ registrar digits.
-      rule(:prefix) { str("10") >> dot >> match("[0-9]").repeat(2).as(:prefix) }
-
-      # Suffix: at least one printable non-whitespace char (DOI Handbook §2.2).
-      rule(:suffix) { match("[A-Za-z0-9._\\-/()]").repeat(1).as(:suffix) }
-
-      rule(:identifier) do
-        url_prefix.maybe >>
-          scheme_prefix.maybe >>
-          slash.maybe >>
-          prefix >> slash >> suffix
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        # Normalize a URL resolver form to bare form before parsing. The
-        # parser's `url_prefix.maybe >> scheme_prefix.maybe >> slash.maybe`
-        # chain also handles this in-grammar, but pre-stripping yields a
-        # cleaner error message for malformed URLs.
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/easc/builder.rb

@@ -2,7 +2,7 @@
 
 module Pubid
   module Easc
-    # Builds an EASC identifier object from the Parslet parse tree.
+    # Builds an EASC identifier object from the parg artifact parse tree.
     class Builder
       def build(parsed)
         series_cyr = stringify(parsed[:series])&.upcase

data/lib/pubid/easc/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Easc
-    # Parslet grammar for EASC identifiers.
+    # Grammar for EASC identifiers.
     #
     # Accepts the Cyrillic surface forms observed in mgscatalog.by:
     #
@@ -16,73 +14,7 @@ module Pubid
     # Also accepts Latin transliterations (PMG, RMG, V) for
     # round-tripping with English-language tooling. The renderer
     # emits Cyrillic as the canonical form.
-    class Parser < ::Pubid::Parser::Grammar
-      include ::Pubid::Parser::CommonParseRules
-
-      root :identifier
-
-      rule(:space)  { str(" ") }
-      rule(:space?) { space.maybe }
-      rule(:dot)    { str(".") }
-
-      # Year separator: ASCII hyphen OR Unicode em-dash / en-dash,
-      # optionally surrounded by whitespace.
-      rule(:year_sep) do
-        space?.maybe >> (str("-") | str("—") | str("–")) >> space?.maybe
-      end
-
-      # Series prefix. Captured to route to the right Identifiers::*
-      # subclass (Pmg vs Rmg). Both Cyrillic and Latin forms.
-      rule(:series_word) do
-        (str("ПМГ") | str("РМГ") | str("PMG") | str("RMG")).as(:series) >> space
-      end
-
-      # Defense variant marker — Cyrillic "В" or Latin "V".
-      rule(:variant_word) do
-        (str("В") | str("V")).as(:variant) >> space
-      end
-
-      rule(:prefix) do
-        series_word >> variant_word.maybe
-      end
-
-      rule(:digits) do
-        match("[0-9]").repeat(1)
-      end
-
-      rule(:number) do
-        (digits >> (dot >> digits).repeat).as(:number)
-      end
-
-      rule(:year_2digit) do
-        match("[0-9]").repeat(2, 2)
-      end
-
-      rule(:year_4digit) do
-        match("[0-9]").repeat(4, 4)
-      end
-
-      rule(:year) do
-        (year_4digit | year_2digit).as(:year)
-      end
-
-      rule(:identifier) do
-        prefix >> number >> (year_sep >> year).maybe
-      end
-
-      def self.parse(string)
-        unless string.is_a?(String)
-          raise ::Pubid::Errors::InvalidInputError,
-                ::Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if string.length > ::Pubid::MAX_INPUT_LENGTH
-          raise ::Pubid::Errors::InvalidInputError,
-                ::Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
-        new.parse(string.strip)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/ecma/CLAUDE.md

@@ -6,7 +6,7 @@ These notes were part of the root `CLAUDE.md`. Read them before you change `lib/
 
 - **ECMA edition and volume — the one flavor whose `to_s` deliberately renders MORE than the document number**: `Relaton::Index::Type#add_or_update` keys on a **bare** `id.to_s` and cannot pass render options, so the default rendering **is** the index key. ECMA's renderer used to say outright that "the edition is never rendered", and 740 of the 804 published `relaton-data-ecma` rows carry one — so all 804 rows collapsed onto **421** keys and **383 were dropped on every crawl, silently** (`ECMA-74` 22 rows to 1, `ECMA-262` 18 to 1). `edition` and `volume` are therefore rendered **by default**, with `to_s(with_edition: false, with_volume: false)` as the opt-out — the inverse of pubid's usual opt-in, and per-flavor divergence in exactly the way 3GPP (`with_publisher: false`) and W3C (`true`) already diverge. **`volume` is a new `attribute :volume, :string`** (relaton's `:vol:`), needed by exactly four rows: ECMA-269 ed3 vol1-4 share one docidentifier **and one title**, so the volume is the only thing separating those four index rows — it is an index discriminator, not something the document prints about itself. Both are plain `:string`s, so `#exclude`/`#matches?` already treat them as wildcards with no override (`ECMA-269` matches every edition under `ignore: %i[edition volume]`); ECMA's `partial_ref_spec.rb` entry moved from `omits: []` to `%i[edition volume]`.
   **Grammar (`lib/pubid/ecma/parser.rb`)**: ` ed<N>` (dotted — `ed5.1` is real, ECMA-402) and ` vol<N>` attach as two independent `.maybe`s **after** the `tr | mem | standard` alternation, so a technical report and a memento carry them exactly as a standard does. The `standard` branch also gained a **space separator** (`ECMA 6`), which is a **NORMALIZING parse** — it renders back as `ECMA-6`, so it lives in `spec/pubid/ecma/edition_volume_spec.rb` and must **never** enter the byte-exact `pass` fixtures (the BIPM `CIPM/2005-06(REV)` precedent). **Two PEG facts are load-bearing and easy to lose.** (1) `standard` cannot shadow ` TR/`/` MEM/` because after the space it demands a **digit** — verified by inverting the alternation order, which still parses both correctly. Keeping `tr | mem` first is belt-and-braces; the **disjoint first character** is the real invariant. (2) Appending a sequence moved the alternation **out of tail position**, so Parslet no longer threads `consume_all` into it and **will not backtrack into an alternative that already succeeded** (`rule(:alt) { str("ab") | str("a") }; rule(:root) { alt >> str("bc") }` fails on `"abc"`). A future branch matching a proper prefix of another branch's input would now fail the whole parse where before it was rescued. `maybe` is `repeat(0,1)` and does not backtrack either, so a marker without its number (` ed`, ` ed5.`, ` vol`) fails atomically and then fails `consume_all` — which is what rejects `ECMA-6 ed` and pins the canonical suffix order (`ECMA-6 vol1 ed3` is rejected).
-  **Render-option threading — `:with_volume` rides the `:trademark` route, deliberately.** `Pubid::Identifier#render` `except`s a flag from the rendering context and `slice`s it to the renderer; `:with_edition` was already in both, and `:trademark` is the precedent for an **IEEE-only** flag carried the same way. So `:with_volume` was added to those two lines and **`build_rendering_context`'s signature was left alone** — widening it would touch `Pubid::Iso::SingleIdentifier`'s strict override. The payoff is that **ECMA's `to_s` needed no change at all** and the renderer owns the defaults: no second transient ivar beside the pre-existing `@with_publisher`, so rendering stays stateless and reentrant. Residual blast radius, accepted: passing `with_volume:` to a *non*-ECMA identifier now reaches that flavor's renderer instead of dying in the context builder — `Renderers::HumanReadable` absorbs unknown opts by design, while ISO's three strict renderers (`DirectivesRenderer`/`IwaRenderer`/`SupplementRenderer`) raise, which they did before too.
+  **Render-option threading — `:with_volume` rides the `:trademark` route, deliberately.** `Pubid::Identifier#render` `except`s a flag from the rendering context and `slice`s it to the renderer; `:with_edition` was already in both, and `:trademark` is the precedent for an **IEEE-only** flag carried the same way. So `:with_volume` was added to those two lines and **`build_rendering_context`'s signature was left alone** — widening it would touch `Pubid::Iso::SingleIdentifier`'s strict override. The payoff is that **ECMA's `to_s` needed no change at all** and the renderer owns the defaults: no transient ivar, so rendering stays stateless and reentrant (the old `@with_publisher` ivar is gone too — see below). Residual blast radius, accepted: passing `with_volume:` to a *non*-ECMA identifier now reaches that flavor's renderer instead of dying in the context builder — `Renderers::HumanReadable` absorbs unknown opts by design, and ISO's three formerly strict renderers (`DirectivesRenderer`/`IwaRenderer`/`SupplementRenderer`) now take `**_opts` as well, because the shared `with_publisher:` flag reaches them.
   **All three identity surfaces, and the two defects found by measuring them.** Per the project rule, edition and volume reach `to_s`, `to_urn` **and** `to_mr_string`. **URN**: labelled segments after the existing `part-<n>` (`urn:ecma:269:ed-3:vol-2`), purely additive — `UrnParser` probes for a labelled prefix (a `shift_labelled` helper using `delete_prefix`, not `sub`), so a URN minted before the segments existed still reads back. The **dot of a decimal edition is KEPT** (`urn:ecma:402:ed-5.1`): `.` is `unreserved` in RFC 8141 and the URN has an inverse, so it must be lossless. **MR**: ECMA defined **no** `mr_*` hooks, so (a) the base `mr_edition` (`edition&.number`) **raised `NoMethodError` on all 740 edition-carrying rows** — the BIPM/ASTM/ASHRAE crash again — and (b) `mr_publisher` was nil (the publisher is the `PUBLISHER` constant, not the inherited attribute) and `mr_type` was nil (the Builder picks a class, it never sets a `typed_stage`), so **`ECMA-101` and `ECMA TR/101` both slugged to `"101"`** and one output filename overwrote the other. Four hooks fix it, sanitising **by charset** (`gsub(/[^a-z0-9]+/, "-")`, the BIPM `mr_slug` precedent) rather than by an escape list. **The MR is deliberately lossy where the URN is not** (`ed5-1` vs `ed-5.1`): `Renderers::MrString` joins **segments** with `.`, so a dot inside one breaks the documented structure, and nothing parses an ECMA MR back (`Parsers::MrString::FLAVOR_MAP` has no ECMA entry). Say so in the comment rather than leaving the asymmetry looking accidental.
   **New shared `mr_volume` slot.** `Renderers::MrString#render_flat` had no volume segment, so it gained one plus a **literal-nil** `mr_volume` hook on `Pubid::Identifier` — literally nil, **not** `volume&.to_s`, because `Pubid::Nist::Identifiers::Base` declares its own `volume` attribute with different MR semantics and a generic reader would silently move NIST's slug. Inert by construction (no flavor defined `mr_volume`, there is no `method_missing` in `lib/pubid`, and NIST overrides `to_mr_string` wholesale), and verified rather than assumed: a `main` baseline replay of `to_mr_string` over all **98,217** identifiers in `spec/fixtures/*/identifiers/pass/*.txt` is **byte-identical**. `render_flat` was rewritten around a frozen `SEGMENTS` list of hook names while it was open, which also cleared a pre-existing ABC offence.
   **The corpus is the gate.** `spec/fixtures/ecma/identifiers/pass/index_corpus.txt` is the complete published index (804 rows) rendered as `"<:id:>[ ed<:ed:>][ vol<:vol:>]"`, generated from `relaton-data-ecma/index-v1.yaml`; `spec/pubid/ecma/corpus_spec.rb` asserts over all of it that every row parses and renders byte-exactly, that `to_s`/`to_urn`/`to_mr_string` each give **804 distinct** keys, that every slug is filename-safe, that the URN and the hash both round-trip, that `from_hash(to_hash) == id` (stronger than hash equality — `#matches?` is built on `==`), and that `root.number` is non-empty. **ECMA has no `identifiers/full/` corpus**, so `rake "validation:classify[ecma]"` cannot run and cannot clobber these files — its fixtures are hand-maintained, unlike every generated flavor. Note ECMA's `fixtures_spec.rb` glob is **correct** (two `..`, lowercase dir) and is not one of the ten dead ones. **Two existing specs asserted the inverted contract** and had to flip (`serialization_spec.rb`'s "omits edition from the printed string"), so a green suite before the code change was the failure signal, not the success one. **relaton note**: this unblocks `relaton__relaton__ecma-consume-index-v2`; `relaton-data-ecma`'s `index-v1` is string-keyed and no ECMA pubid index is published yet, so nothing needs migrating — but the crawl must run after this lands, or the rows key on the collapsed form again. (hand-off: ecma-edition-and-volume.)
@@ -26,3 +26,10 @@ keeps `#matches?(other, ignore:)`.
   before the declaration existed. `edition` and `volume` stay wildcards —
   an omitted edition really does mean "any edition", which is why
   `partial_ref_spec.rb` lists them under `omits`.
+
+- **`with_publisher: false` keeps the `ECMA` token.** `ECMA-262` is how ECMA
+  cites its own standard; the old `false` form gave `-262` and `TR/101`, which
+  are no designation. `#publisher_prefixes` returns `[]`, so the shared
+  stripper (root `CLAUDE.md`, the `with_publisher:` bullet) leaves the string
+  alone, and the `@with_publisher` ivar and the renderer branch that read it
+  were deleted. XSF made the same change for `XEP 0001`.

data/lib/pubid/ecma/identifier.rb

@@ -63,21 +63,26 @@ module Pubid
       # would otherwise fail serialization type validation.
       PUBLISHER = "ECMA"
 
-      # Whether the last `to_s` should include the "ECMA" publisher token.
-      attr_reader :with_publisher
-
-      # Basic string representation. Delegates to renderer. `with_publisher:
-      # false` drops the ECMA token (e.g. "-411", "TR/84").
+      # Basic string representation. Delegates to renderer.
       #
       # The edition and volume suffixes are rendered by DEFAULT and are opted
       # out of with `to_s(with_edition: false, with_volume: false)`. Both flags
       # ride in `opts` to the renderer, which owns their defaults — see
       # Pubid::Ecma::Renderer for why the default is "with".
-      def to_s(with_publisher: true, **opts)
-        @with_publisher = with_publisher
+      #
+      # `with_publisher:` is accepted and has no effect: `ECMA` is part of the
+      # designation (`ECMA-262`), not a publisher prefix, so the internal form
+      # is the external one (see {#publisher_prefixes}).
+      def to_s(**opts)
         render(format: :human, **opts)
       end
 
+      # `ECMA-262` is how ECMA itself cites the standard; dropping the token
+      # leaves `-262` or `262`, which is no designation at all.
+      def publisher_prefixes
+        []
+      end
+
       # Type token that precedes the number ("TR"/"MEM"), or nil for standards.
       # Overridden by each concrete identifier class.
       def type_prefix
@@ -129,7 +134,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:ecma, identifier)
+        parsed = Pubid::Parg::Model.bound(:ecma, identifier)
         Builder.build(parsed)
       end