pubid 2.0.1 → 2.0.3

data/lib/pubid/jcgm/builder.rb

@@ -24,7 +24,18 @@ module Pubid
         Jcgm.locate_type(typed_stage.type_code)
       end
 
+      # The bound grammar flattens the old `(base as base)` wrapper (the
+      # bindings cannot nest): the base document keeps the canonical
+      # number/date captures and the supplement layer captures
+      # supp_number/supp_date. Rebuild the nested shape the builder has
+      # always consumed — the base fields rename under :base and the
+      # supplement layer takes type_with_stage plus its own
+      # supp_number/supp_date, which is exactly the tree the
+      # amendment/corrigendum rules produced before the flatten.
+      SUPPLEMENT_STAGES = %w[Amd Cor Corrigendum].freeze
+
       def build(parsed_hash)
+        parsed_hash = unflatten_supplement(parsed_hash)
         klass = locate_identifier_klass(parsed_hash)
 
         # GUM guides store their part number in the shared `number` attribute
@@ -52,6 +63,30 @@ module Pubid
 
       private
 
+      def unflatten_supplement(parsed_hash)
+        stage = parsed_hash[:type_with_stage]
+        return parsed_hash if parsed_hash[:base] || stage.nil? ||
+          !SUPPLEMENT_STAGES.include?(stage)
+
+        base_hash = {}
+        %i[publisher number gum_number date languages].each do |key|
+          base_hash[key] = parsed_hash.delete(key) if parsed_hash[key]
+        end
+        stage = parsed_hash.delete(:type_with_stage)
+        supplement_hash = { type_with_stage: stage }
+        if parsed_hash[:supp_number]
+          supplement_hash[:number] = parsed_hash.delete(:supp_number)
+        end
+        if parsed_hash[:supp_date]
+          supplement_hash[:date] = parsed_hash.delete(:supp_date)
+        end
+        # Keep the base as a raw hash: the shared assign_attributes loop
+        # routes :base through cast, which recursively builds it — the
+        # same path the tree backend's nested subtree took.
+        supplement_hash[:base] = base_hash
+        parsed_hash.merge(supplement_hash)
+      end
+
       def default_identifier_class
         Identifiers::Guide
       end

data/lib/pubid/jcgm/parser.rb

@@ -1,158 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Jcgm
-    class Parser < ::Pubid::Parser::Grammar
-      include ::Pubid::Parser::CommonParseRules
-      include ::Pubid::Parser::CommonParseMethods
-
-      root :identifier
-
-      rule(:identifier) do
-        meeting_identifier | amendment_identifier | corrigendum_identifier |
-          numbered_corrigendum_identifier | base | named_guide_identifier
-      end
-
-      # "JCGM 200:2008 Corrigendum" — a base guide plus a trailing
-      # " Corrigendum" word (no number). Must precede base: Parslet
-      # is an ordered PEG that commits to the first matching alternative, so if
-      # base ran first it would consume "JCGM 200:2008" and root
-      # would fail on the leftover " Corrigendum". Emits type_with_stage so the
-      # builder routes it to Corrigendum.
-      rule(:corrigendum_identifier) do
-        base.as(:base) >> space >>
-          str("Corrigendum").as(:type_with_stage)
-      end
-
-      # "JCGM 101:2008/Cor 1:2009" — a base guide plus a slash-separated
-      # numbered corrigendum (mirrors the ISO/IEC supplement form). The
-      # trailing :YYYY is optional so "JCGM 101:2008/Cor 1" also parses.
-      # Must precede base for the same PEG-commit reason as corrigendum_identifier.
-      rule(:numbered_corrigendum_identifier) do
-        base.as(:base) >>
-          str("/") >> str("Cor").as(:type_with_stage) >>
-          supplement_separator >> digits.as(:number) >>
-          corrigendum_date.maybe
-      end
-
-      # "Amd 1" and the dotted "Amd.1:2026" BIPM prints on its
-      # publications page (bipm.org, JCGM 100:2008/Amd.1:2026) are both
-      # accepted on input; rendering stays "Amd 1".
-      rule(:supplement_separator) do
-        space | (str(".") >> space.maybe)
-      end
-
-      # Dateless "named" guides: "JCGM GUM", "JCGM VIM-3" (and future "VIM-N").
-      # Last in the alternation — only reached when base fully fails
-      # (these have no date, so number_portion/date_portion never match).
-      rule(:named_guide_identifier) do
-        publisher >> space >> named_number
-      end
-
-      rule(:named_number) do
-        (str("GUM") | (str("VIM") >> (str("-") >> digits).maybe)).as(:number)
-      end
-
-      # Committee/meeting record, e.g. "JCGM 17th Meeting (2012)". Diverges
-      # from base right after the digits (base wants ":", meeting
-      # wants the ordinal suffix), so ordered choice is unambiguous. Emits the
-      # same tokens as a guide plus type_with_stage "Meeting", so the generic
-      # builder path resolves it to Identifiers::Meeting (like "Amd").
-      #
-      # The trailing " (YYYY)" group is optional, so the partial reference
-      # "JCGM 11st Meeting" parses with `date` left nil. JCGM numbers its
-      # meetings in one sequence, so the ordinal alone names the event and the
-      # year is redundant detail. The whole group is `.maybe` (not the year
-      # inside it), so a dangling "(" or a truncated year still fails —
-      # the same shape as `date_portion.maybe` in `rule(:base)`.
-      rule(:meeting_identifier) do
-        publisher >> space >> digits.as(:number) >> ordinal_suffix >>
-          space >> str("Meeting").as(:type_with_stage) >>
-          (space >> str("(") >> year_digits.as(:date) >> str(")")).maybe
-      end
-
-      rule(:ordinal_suffix) do
-        str("st") | str("nd") | str("rd") | str("th")
-      end
-
-      # `date_portion` is optional so a partial reference that omits the
-      # trailing `:YYYY` date (e.g. "JCGM 100") parses with `date` left nil,
-      # letting relaton match a collection via `matches?(row, ignore: [:date])`.
-      # The whole sub-rule is `.maybe` (not the year inside it) so a dangling
-      # ":" still fails. Mirrors ETSI (lib/pubid/etsi/parser.rb).
-      rule(:base) do
-        publisher >> space >> number_portion >>
-          date_portion.maybe >> language_portion.maybe
-      end
-
-      rule(:amendment_identifier) do
-        base.as(:base) >>
-          str("/") >> amendment_type >>
-          supplement_separator >> digits.as(:number) >>
-          amendment_date.maybe
-      end
-
-      rule(:publisher) do
-        str("JCGM").as(:publisher)
-      end
-
-      # Number can be plain (100, 200) or GUM-prefixed (GUM-1, GUM-6)
-      rule(:number_portion) do
-        gum_number | standard_number
-      end
-
-      rule(:standard_number) do
-        digits.as(:number)
-      end
-
-      rule(:gum_number) do
-        str("GUM-") >> digits.as(:gum_number)
-      end
-
-      # Date can be YYYY or YYYY-MM-DD
-      rule(:date_portion) do
-        str(":") >> (full_date | year_only)
-      end
-
-      rule(:year_only) do
-        year_digits.as(:date)
-      end
-
-      rule(:full_date) do
-        (year_digits >> str("-") >> month_digits >> str("-") >> day_digits).as(:date)
-      end
-
-      # Language: "(E)", "(F)", "(E/F)", "(F/E)"
-      rule(:language_portion) do
-        str("(") >>
-          (
-            # Multi-language: E/F, F/E
-            (str("E/F") | str("F/E")) |
-            # Single language: E, F, R, etc.
-            match("[A-Z]")
-          ).as(:languages) >>
-          str(")")
-      end
-
-      # Amendment support
-      rule(:amendment_type) do
-        str("Amd").as(:type_with_stage)
-      end
-
-      rule(:amendment_number) do
-        digits.as(:number)
-      end
-
-      rule(:amendment_date) do
-        str(":") >> (full_date | year_only)
-      end
-
-      # Numbered corrigendum date: same shape as amendment_date.
-      rule(:corrigendum_date) do
-        str(":") >> (full_date | year_only)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/jcgm.rb

@@ -32,10 +32,9 @@ module Pubid
         raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
-      parser = Parser.new
       builder = Builder.new
 
-      parsed = Pubid::Parg::Backend.parse(:jcgm, identifier)
+      parsed = Pubid::Parg::Model.bound(:jcgm, identifier)
       builder.build(parsed)
     end
 

data/lib/pubid/jis/CLAUDE.md

@@ -0,0 +1,36 @@
+# JIS flavor notes
+
+## WES lives in the JIS flavor (relaton-jis#18)
+
+- WES (Japan Welding Engineering Society) ids — `WES 7700-1:2019`,
+  `WES 7301:2020R` — parse as `Identifiers::WeldingEngineeringStandard`
+  (`_type: pubid:jis:welding-engineering-standard`). JSA Webdesk sells WES next
+  to JIS and relaton crawls both into one `relaton-data-jis` index, so a
+  separate `Pubid::Wes` flavor was rejected.
+- **Grammar**: `data/parg/jis.json` is `identifier = wes_identifier /
+  jis_identifier`. The WES branch is `"WES" space number parts …` with the same
+  tail as JIS (year, `R`, language, 規格群, supplements, SYMBOL) and binds a
+  `wes` capture, which the builder keys on. `JIS WES 7700` and `WES X 7700`
+  are rejected: the JIS prefix and a series letter belong only to JIS. The
+  source of record is pubid/pubid-grammar; the artifact was rebaked here with
+  parsanol **1.3.114** — the PATH `parsanol` shim may be a newer version, so
+  bake with the 1.3.114 gem's `exe/parsanol` and check `compiler_version`.
+- **`series` is nil** for WES (JIS keeps its `""`-coerced String), so the hash
+  carries no `series` key. `number` is the bare number (`"7700"`), the index
+  key.
+- **"WES" is the root, not a publisher**: `publisher_prefix` is nil, `code`
+  is `"WES 7700-1"`, so `to_s(with_publisher: false)` still prints `WES …`,
+  also as the base of a supplement. The URN is `urn:jis:WES 7700-1:2019`;
+  `UrnParser` does not prepend `JIS ` to a code that starts with `WES `.
+- `PREFIXES` includes `"WES"`, so `Pubid.parse("WES …")` routes to JIS.
+
+## Equality includes the class
+
+- `Identifier#==` requires `other.instance_of?(self.class)`: `JIS TR X
+  0014:1999` is not `JIS X 0014:1999` (3 such pairs are in the published
+  index), and `WES 7700` is never a JIS standard. `#matches?` follows, since it
+  compares `exclude(…)` results with `==`.
+- `SupplementIdentifier#==` also compares `symbol` and `reaffirmed?`:
+  `…/AMD 3:2025R SYMBOL 65700` is not `…/AMD 3:2025`.
+- The all-parts match is `===` (`Pubid::AllParts`), not `==`, and is
+  unchanged.

data/lib/pubid/jis/builder.rb

@@ -9,12 +9,14 @@ module Pubid
 
       def build(data)
         # Handle supplement case first; the SYMBOL clause (if any) attaches to
-        # the outermost identifier, be it the base or the supplement.
-        identifier = if data[:amendment]
+        # the outermost identifier, be it the base or the supplement. The
+        # bindings bind the supplement's fields flat (amd_type/amd_number/…),
+        # so their presence marks the supplement kind.
+        identifier = if data[:amd_type]
                        build_amendment(data)
-                     elsif data[:explanation]
+                     elsif data[:expl_type]
                        build_explanation(data)
-                     elsif data[:corrigendum]
+                     elsif data[:corr_type]
                        build_corrigendum(data)
                      else
                        build_single_identifier(data)
@@ -35,72 +37,59 @@ module Pubid
 
       def build_single_identifier(data)
         attrs = {
-          series: data[:series].to_s,
           number: data[:number].to_s,
           parts: extract_part_strings(data[:parts]),
           year: data[:year]&.to_i,
           language: data[:language]&.to_s,
           reaffirmed: (true if data[:reaffirmed]),
         }
+        # A WES id carries no series letter, so its series stays nil.
+        wes = Identifiers::WeldingEngineeringStandard
+        return wes.new(**attrs) if data[:wes]
 
-        # Determine identifier class from type
-        type = data[:type]&.to_s
-        klass = case type
-                when "TR"
-                  Identifiers::TechnicalReport
-                when "TS"
-                  Identifiers::TechnicalSpecification
-                else
-                  Identifiers::JapaneseIndustrialStandard
-                end
+        jis_class_for_type(data[:type]&.to_s)
+          .new(series: data[:series].to_s, **attrs)
+      end
 
-        klass.new(**attrs)
+      def jis_class_for_type(type)
+        case type
+        when "TR" then Identifiers::TechnicalReport
+        when "TS" then Identifiers::TechnicalSpecification
+        else Identifiers::JapaneseIndustrialStandard
+        end
       end
 
       def build_amendment(data)
-        amd_data = data[:amendment]
-
-        # Build base document (without supplement)
-        base_data = data.except(:amendment)
-        base = build_single_identifier(base_data)
+        # The bindings carry the supplement's fields at the top level; the
+        # base document shares them.
+        base = build_single_identifier(data)
 
-        # Build amendment
         Identifiers::Amendment.new(
           base: base,
-          number: amd_data[:amd_number].to_i,
-          year: amd_data[:amd_year].to_i,
-          reaffirmed: (true if amd_data[:amd_reaffirmed]),
+          number: data[:amd_number].to_i,
+          year: data[:amd_year].to_i,
+          reaffirmed: (true if data[:amd_reaffirmed]),
         )
       end
 
       def build_explanation(data)
-        expl_data = data[:explanation]
+        base = build_single_identifier(data)
 
-        # Build base document (without supplement)
-        base_data = data.except(:explanation)
-        base = build_single_identifier(base_data)
-
-        # Build explanation
         Identifiers::Explanation.new(
           base: base,
-          number: expl_data[:expl_number]&.to_i,
+          number: data[:expl_number]&.to_i,
           year: base.year,
         )
       end
 
       def build_corrigendum(data)
-        corr_data = data[:corrigendum]
-
-        # Build base document (without supplement)
-        base_data = data.except(:corrigendum)
-        base = build_single_identifier(base_data)
+        base = build_single_identifier(data)
 
-        # Build corrigendum
         Identifiers::Corrigendum.new(
           base: base,
-          number: corr_data[:corr_number].to_i,
-          year: corr_data[:corr_year].to_i,
-          reaffirmed: (true if corr_data[:corr_reaffirmed]),
+          number: data[:corr_number].to_i,
+          year: data[:corr_year].to_i,
+          reaffirmed: (true if data[:corr_reaffirmed]),
         )
       end
 

data/lib/pubid/jis/identifier.rb

@@ -43,6 +43,8 @@ module Pubid
         "pubid:jis:amendment" => "Pubid::Jis::Identifiers::Amendment",
         "pubid:jis:corrigendum" => "Pubid::Jis::Identifiers::Corrigendum",
         "pubid:jis:explanation" => "Pubid::Jis::Identifiers::Explanation",
+        "pubid:jis:welding-engineering-standard" =>
+          "Pubid::Jis::Identifiers::WeldingEngineeringStandard",
       }.freeze
 
       key_value do
@@ -63,6 +65,12 @@ module Pubid
       # would otherwise fail serialization type validation.
       PUBLISHER = "JIS"
 
+      # The token the human render prints before the designation, and drops
+      # for `to_s(with_publisher: false)`; nil when the designation has none.
+      def publisher_prefix
+        PUBLISHER
+      end
+
       def reaffirmed?
         reaffirmed == true
       end
@@ -88,8 +96,10 @@ module Pubid
         result
       end
 
+      # The class is part of the identity: "JIS TR X 0014:1999" is not
+      # "JIS X 0014:1999", and "WES 7700" is not a JIS standard.
       def ==(other)
-        return false unless other.is_a?(Identifier)
+        return false unless other.instance_of?(self.class)
 
         series == other.series &&
           number == other.number &&
@@ -174,7 +184,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:jis, identifier)
+        parsed = Pubid::Parg::Model.bound(:jis, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/jis/identifiers/welding_engineering_standard.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jis
+    module Identifiers
+      # Japan Welding Engineering Society standard. JSA sells WES next to JIS,
+      # so it parses through the JIS flavor, but the id carries no series
+      # letter and no JIS prefix.
+      # Examples: WES 7700-1:2019, WES 7301:2020R
+      class WeldingEngineeringStandard < SingleIdentifier
+        PUBLISHER = "WES"
+
+        def type_prefix
+          nil
+        end
+
+        # "WES" is the root of the designation, not a publisher token, so
+        # `to_s(with_publisher: false)` keeps it.
+        def publisher_prefix
+          nil
+        end
+
+        def code
+          result = "#{PUBLISHER} #{number}"
+          result += parts.map { |p| "-#{p}" }.join if parts&.any?
+          result
+        end
+
+        def mr_publisher
+          PUBLISHER.downcase
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jis/identifiers.rb

@@ -13,6 +13,8 @@ module Pubid
       autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
       autoload :TechnicalSpecification,
                "#{__dir__}/identifiers/technical_specification"
+      autoload :WeldingEngineeringStandard,
+               "#{__dir__}/identifiers/welding_engineering_standard"
     end
   end
 end

data/lib/pubid/jis/parser.rb

@@ -1,135 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Jis
-    class Parser < ::Pubid::Parser::Grammar
-      # Japanese character normalization
-      rule(:jp_dash) { str("ｰ") } # Full-width dash
-      rule(:jp_space) { str("　") }  # Full-width space
-      rule(:jp_colon) { str("：") }  # Full-width colon
-      rule(:jp_lparen) { str("（") }
-      rule(:jp_rparen) { str("）") }
-
-      # Normalized separators
-      rule(:dash) { (str("-") | jp_dash).as(:dash) }
-      rule(:space) { str(" ") | jp_space }
-      rule(:colon) { str(":") | jp_colon }
-
-      # Basic elements
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-      rule(:letter) { match["A-Z"] }
-
-      # JIS prefix (optional, handles both "JIS " and "JIS/")
-      rule(:jis_prefix) { str("JIS") >> (space | str("/")).maybe }
-
-      # Type prefix (TR or TS, can come with or without slash)
-      rule(:type_prefix) do
-        (str("TR") | str("TS")).as(:type) >> (space | str("/"))
-      end
-
-      # Series letter
-      rule(:series) { letter.as(:series) }
-
-      # Number (preserve as string to maintain leading zeros)
-      rule(:number) { digits.as(:number) }
-
-      # Parts (multi-level: -1, -2-1, -3-2-1, etc.)
-      rule(:part) do
-        dash >> digits.as(:part)
-      end
-
-      rule(:parts) { part.repeat(0).as(:parts) }
-
-      # Reaffirmation marker (再確認): trailing "R" on a year
-      rule(:reaffirmed) { str("R").maybe.as(:reaffirmed) }
-
-      # Year
-      rule(:year) do
-        colon >> digits.as(:year) >> reaffirmed
-      end
-
-      # Language code
-      rule(:language) do
-        (str("(") | jp_lparen) >>
-          match["EJ"].as(:language) >>
-          (str(")") | jp_rparen)
-      end
-
-      # All-parts notation (Japanese)
-      rule(:all_parts) do
-        ((jp_lparen >> str("規格群") >> jp_rparen) |
-         (str("(") >> str("規格群") >> str(")"))).as(:all_parts)
-      end
-
-      # Amendment supplement
-      rule(:amendment) do
-        str("/") >>
-          (str("AMENDMENT") | str("AMD")).as(:amd_type) >>
-          space >>
-          digits.as(:amd_number) >>
-          colon >>
-          digits.as(:amd_year) >>
-          str("R").maybe.as(:amd_reaffirmed)
-      end
-
-      # Explanation supplement
-      rule(:explanation) do
-        str("/") >>
-          (str("EXPLANATION") | str("EXPL")).as(:expl_type) >>
-          (space >> digits.as(:expl_number)).maybe
-      end
-
-      # Corrigendum supplement
-      rule(:corrigendum) do
-        str("/") >>
-          (str("CORRIGENDUM") | str("CORR")).as(:corr_type) >>
-          space >>
-          digits.as(:corr_number) >>
-          colon >>
-          digits.as(:corr_year) >>
-          str("R").maybe.as(:corr_reaffirmed)
-      end
-
-      # Supplements (AMD, EXPL or CORRIGENDUM, only one for JIS)
-      rule(:supplement) do
-        amendment.as(:amendment) | explanation.as(:explanation) |
-          corrigendum.as(:corrigendum)
-      end
-
-      # Graphical-symbol sub-reference (e.g. JIS Z 8210 safety signs):
-      # "SYMBOL <id>" where <id> runs to the end of the string and may be a
-      # number, an alphanumeric code or a free-text phrase. The keyword may
-      # also appear bare with no value.
-      rule(:symbol_clause) do
-        space >> str("SYMBOL").as(:symbol_present) >>
-          (space >> match["^\n"].repeat(1).as(:symbol_value)).maybe
-      end
-
-      # Main identifier
-      rule(:identifier) do
-        jis_prefix.maybe >>
-          type_prefix.maybe >>
-          space.maybe >>
-          series >>
-          space.maybe >>
-          number >>
-          parts >>
-          year.maybe >>
-          language.maybe >>
-          all_parts.maybe >>
-          supplement.maybe >>
-          symbol_clause.maybe
-      end
-
-      rule(:root) { identifier }
-
-      # Parse and normalize Japanese characters
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/jis/renderer.rb

@@ -44,7 +44,7 @@ module Pubid
       def render_single(id)
         with_pub = with_publisher?(id)
         parts = []
-        parts << PUBLISHER if with_pub
+        parts << id.publisher_prefix if with_pub && id.publisher_prefix
         parts << id.type_prefix if id.class.method_defined?(:type_prefix) && id.type_prefix
         result = parts.join(" ")
         result += " " if result.length.positive?

data/lib/pubid/jis/supplement_identifier.rb

@@ -38,12 +38,12 @@ module Pubid
       end
 
       def ==(other)
-        return false unless other.is_a?(SupplementIdentifier)
-        return false unless other.class == self.class
+        return false unless other.instance_of?(self.class)
 
-        base == other.base &&
-          number == other.number &&
-          year == other.year
+        # A supplement carries its own reaffirmation and SYMBOL clause.
+        %i[base number year reaffirmed? symbol].all? do |field|
+          public_send(field) == other.public_send(field)
+        end
       end
     end
   end

data/lib/pubid/jis/urn_parser.rb

@@ -9,12 +9,13 @@ module Pubid
     #
     # Examples:
     # - urn:jis:X 0201:1997 → JIS X 0201:1997
+    # - urn:jis:WES 7700-1:2019 → WES 7700-1:2019 (the code carries its root)
     class UrnParser < Pubid::UrnParser::Base
       def parse_urn(urn)
         body = strip_namespace(urn)
         parts = split_parts(body)
         code, year = parts
-        text = "JIS #{code}"
+        text = code.to_s.start_with?("WES ") ? code.dup : "JIS #{code}"
         text += ":#{year}" if year
         flavor_parse(text)
       end

data/lib/pubid/jis.rb

@@ -5,9 +5,10 @@ module Pubid
   module Jis
     extend Pubid::PrefixesSupport
 
-    # Sole JIS publisher token (see the parser's `jis_prefix` rule). Document
+    # The JIS publisher token, and WES, the root of a Japan Welding
+    # Engineering Society id (the grammar's `wes_identifier` rule). Document
     # types (TR/TS) follow the JIS prefix and are excluded.
-    PREFIXES = ["JIS"].freeze
+    PREFIXES = ["JIS", "WES"].freeze
 
     autoload :Builder, "#{__dir__}/jis/builder"
     autoload :Identifier, "#{__dir__}/jis/identifier"

data/lib/pubid/nist/builder.rb

@@ -85,9 +85,13 @@ module Pubid
 
         # NEW: Check for CIRC supplement pattern
         # Note: :base_portion is lost during parser merge, so check for supplement indicators
+        # circ_series routes the bare "NBS.CIRC.sup" form: the edition-2
+        # grammar cannot carry the zero-width supplement_empty marker the
+        # Parslet tree used, and the series capture marks every circular
+        # supplement head.
         if parsed_hash[:supplement_date_range] || parsed_hash[:supplement_slash_year] ||
             parsed_hash[:supplement_month_year] || parsed_hash[:supplement_year] ||
-            parsed_hash[:supplement_empty] ||
+            parsed_hash[:supplement_empty] || parsed_hash[:circ_series] ||
             parsed_hash[:supplement] || parsed_hash[:base_portion]
           return build_circular_supplement(parsed_hash)
         end