pubid 2.0.1 → 2.0.3

data/lib/pubid/iec/parser.rb

@@ -1,437 +1,14 @@
-require "parslet"
 # frozen_string_literal: true
 
 module Pubid
   module Iec
-    class Parser < ::Pubid::Parser::Grammar
-      include ::Pubid::Parser::CommonParseRules
-      include ::Pubid::Parser::CommonParseMethods
-
+    class Parser
       DASH_CHARS = ["-", "‑", "‐"].freeze
 
-      # We need to sort by length to match longest first because that's how Parslet works
-      TYPED_STAGES = Pubid::Iec.all_typed_stages
-        .map(&:abbr).flatten.sort_by(&:length).reverse
-      TYPED_STAGES_SUPPLEMENTS = TYPED_STAGES
-
-      root :identifier
-
-      rule(:identifier) do
-        working_programme |
-          technical_group |
-          working_document |
-          sheet_supplement_identifier |
-          sheet_identifier |
-          supplement_supplement_identifier |
-          standalone_supplement |
-          supplement_identifier |
-          joint_identifier |
-          identifier_copublishers
-      end
-
-      # Technical Group identifier — names a committee rather than a document.
-      # Examples: "IEC TC 1", "ISO/IEC JTC 1", "ISO/IEC JTC 1/SC 7",
-      #           "IEC SC 100A", "CISPR", "CIS/A".
-      rule(:technical_group) do
-        technical_group_with_publisher | technical_group_bare
-      end
-
-      rule(:technical_group_with_publisher) do
-        prefix_sole_publisher >> copublishers.maybe >> space >>
-          tc_body.as(:technical_committee) >>
-          (str("/") >> space? >> sc_body).as(:subcommittee).maybe
-      end
-
-      rule(:technical_group_bare) do
-        # CISPR / CIS-letter forms and bare TYPE NUMBER forms both default
-        # publisher to "IEC" via the Base class default.
-        tc_body.as(:technical_committee) >>
-          (str("/") >> space? >> sc_body).as(:subcommittee).maybe
-      end
-
-      # Committee body forms accepted by the parser. Order matters: longer
-      # or more specific patterns first so they win the ordered choice.
-      rule(:tc_body) do
-        str("CISPR") |
-          (str("CIS") >> str("/") >> match("[A-Z]")) |
-          (tc_type >> space >> digits >> match("[A-Z]").maybe)
-      end
-
-      rule(:sc_body) do
-        str("SC") >> space >> digits >> match("[A-Z]").maybe
-      end
-
-      rule(:tc_type) do
-        str("JTC") | str("JPC") | str("TC") | str("SC") | str("PC")
-      end
-
-      # Working Programme format: [PWI|PNW] [TR] number edition
-      # Examples: "PWI TR 100-36 ED1", "PWI 100-44 ED1", "PNW 65-915 ED1"
-      # TC-style names: "PWI TR SYCSMARTENERGY-1", "PWI SyCLVDC-1 ED1"
-      rule(:working_programme) do
-        (str("PWI") | str("PNW")).as(:wp_stage) >>
-          space >>
-          (
-            (str("TR") >> space) |
-            (str("TS") >> space) |
-            (str("SRD") >> space)
-          ).maybe.as(:wp_type) >>
-          wp_number >>
-          (space >> edition).maybe
-      end
-
-      # Working programme numbers can be digits or TC names
-      rule(:wp_number) do
-        # TC-style: SYCSMARTENERGY-1, SyCLVDC-125
-        (match("[A-Za-z]").repeat(1) >> match('[A-Za-z\d]').repeat >> (dash >> match('\d').repeat(1)).maybe).as(:number_with_part) |
-          # Regular numeric: 100-36
-          number_with_part
-      end
-
-      # Working Document format: TC/number/stage
-      # TC can be: slashes (CIS/D), hyphens (JTC1-SC41), simple (100, 86B, ACEA, SyCSmartEnergy)
-      # Examples: "CIS/D/468A/CC", "JTC1-SC41/251/FDIS", "100/3705(F)/FDIS", "86B/4347A/CC"
-      rule(:working_document) do
-        # TC patterns: digits (100), letters (ACEA), letters/letters (CIS/D), or complex (JTC1-SC41)
-        (
-          # Try specific patterns first
-          (str("JTC1-SC") >> match('\d').repeat(1)) | # JTC1-SC41
-          (match("[A-Z]").repeat(1) >> str("/") >> match("[A-Z]").repeat(1)) | # CIS/D
-          match('[A-Za-z\d]').repeat(1) # Simple: 100, 86B, ACEA, SyCSmartEnergy
-        ).as(:technical_committee) >>
-          str("/") >>
-          match('[A-Za-z\d]').repeat(1).as(:wd_number) >>
-          (str("(") >> match("[A-Z]").as(:wd_language) >> str(")")).maybe >>
-          (str("/") >> match("[A-Z]").repeat(1).as(:wd_stage)).maybe
-      end
-
-      # IEC 60038:2009
-      # ISO/IEC 17025:2017
-      # CISPR 11:2015 (special IEC publisher)
-      # IECQ 080000:2017 (special IEC publisher)
-      # IECEE (IEC System for Conformity Assessment)
-      # IECEx (IEC System for Certification to Standards)
-      # IEC CA (IEC Conformity Assessment)
-      # IECQ CS (IECQ Component Specifications)
-      # IECQ OD (IECQ Operational Documents)
-      rule(:prefix_sole_publisher) do
-        (
-          str("IECQ OD") |
-          str("IECQ CS") |
-          str("IEC CAB") |
-          str("IEC CA") |
-          str("IECRE") |
-          str("CISPR") |
-          str("IECEE") |
-          str("IECEx") |
-          str("IECQ") |
-          str("IEC") |
-          str("ISO")
-        ).as(:publisher)
-      end
-
-      # ISO/IEC or IEC
-      rule(:prefix_with_copublishers) do
-        prefix_sole_publisher >> space? >> copublishers.maybe
-      end
-
-      ORGANIZATIONS = %w[
-        IEC ISO IEEE CIW SAE CIE ASME ASTM OECD HL7 CEI UNDP
-      ].freeze
-      rule(:copublishers) do
-        (str("/") >> space? >> array_to_str(ORGANIZATIONS).as(:copublisher)).repeat.as(:copublishers)
-      end
-
-      rule(:number_with_part) do
-        (number >> part_and_subpart.maybe).as(:number_with_part)
-      end
-
-      # For TRF with organization prefix: "CISPR 14-1G" where CISPR is part of the number
-      rule(:trf_org_number) do
-        (str("CISPR") >> space).as(:trf_org) >> number_with_part
-      end
-
-      rule(:number) do
-        # ISO/IEC Directives: "DIR", "DIR 1", "DIR 1 IEC SUP", "DIR 2 IEC", "DIR IEC SUP"
-        # Captured as a flat number (no part/subpart) so it round-trips to the input
-        # and class-matches the IEC index. Must come before the IECEE [A-Z]{2,4} branch,
-        # which would otherwise match "DIR" alone and leave the trailing tokens unconsumed.
-        (str("DIR") >> (space >> match('[A-Z\d]').repeat(1)).repeat) |
-          # Special case for VIM publication
-          str("VIM") |
-          # Special case for SYMBOL publication
-          str("SYMBOL") |
-          # IECEx TRF version notation: 62784v1a_ds, 62784v1A
-          (match('\d').repeat(1,
-                              6) >> str("v") >> match('\d').repeat(1) >> match("[a-zA-Z]").repeat >> (str("_") >> match("[a-zA-Z]").repeat).maybe) |
-          # IECEE letter-based numbers: AD-001, GD-2053, OD-1000, CAB-G01, 01-S
-          # Pattern: 2-4 letter prefix followed by optional dash and number
-          # The suffix uses [A-Z\d] but not space to properly separate from edition
-          (match("[A-Z]").repeat(2, 4) >> (
-            dash >> match('\d').repeat(1)
-          ).maybe >> match('[A-Z\d]').repeat) |
-          # Can be 5-6 digits for TRF: 60065, 610091
-          # Can have letter suffix: 60065N, 610091A
-          # Can have letter + underscore + letters: 61215F_SE
-          (match('\d').repeat(1, 6) >> (
-            match("[a-zA-Z]") >> (str("_") >> match("[a-zA-Z]").repeat).maybe
-          ).maybe)
-      end
-
-      rule(:date) do
-        # :2005-02 or :-- (undated reference — ISO/IEC undated-reference form,
-        # e.g. IEC 60050:--, also accepted as the em-dash variant IEC 60050:—)
-        (str(":") | dash) >>
-          (
-            (str("--") | str("—")).as(:undated_marker) |
-              (year_digits >>
-                (dash >> month_digits).maybe >>
-                (dash >> day_digits).maybe
-              ).as(:date)
-          )
-      end
-
-      rule(:part_and_subpart) do
-        # Parts can have:
-        # - Dashes: 60038-1
-        # - Complex: 29110-5-1-1
-        # - TRF ampersand: 60086-1&2A
-        # - TRF underscore: 60127-2-IA_I, 61215F_SE
-        # - TRF lowercase: 60127-2-iD_I
-        # - TRF commas: 60309-1,2G or 60335-1-14,15G
-
-        # the "space?" needed to handle potential spaces
-        (dash | str(",")) >> space? >>
-          # matches a part with special TRF characters including commas
-          match('[\w&_,]').repeat >>
-          # matches subparts
-          ((dash | str(",")) >> match('[\w&_,]').repeat).repeat.maybe
-      end
-
-      rule(:all_parts) do
-        str("(all parts)").as(:all_parts)
-      end
-
-      rule(:type_with_stage) do
-        # "DTR"
-        # "TS"
-        # "Guide"
-        # Also includes supplement stages like "CDCor" for standalone draft corrigenda
-        array_to_str(TYPED_STAGES + TYPED_STAGES_SUPPLEMENTS).as(:type_with_stage) >>
-          (match('\d').as(:stage_iteration) >> space).maybe
-      end
-
-      rule(:language) do
-        # IEC 60038:2009(en,fr)
-        # IEC 60038:2009(en-fr) (house style, pubid#491)
-        # IEC 60038:2009(E/F)
-        str("(") >>
-          (
-            # parse 2-char language codes: ru,en,fr,de,ar,es
-            (match["a-z"].repeat(1) >> (str(",") | str("-")).maybe) |
-            # parse single language codes: R/E/F
-            (match["EFARDS"] >> str("/").maybe)
-          ).repeat.as(:languages) >>
-          str(")")
-      end
-
-      EDITION_STRINGS = %w[Edition Ed. ED Ed].freeze
-      rule(:edition) do
-        # We ignore the case where there is "Ed" but no number
-        # Handle decimal editions like ED1.2
-        array_to_str(EDITION_STRINGS) >> space? >>
-          (digits >> (str(".") >> digits).maybe).maybe.as(:edition)
-      end
-
-      rule(:stage_iteration) do
-        # "IEC 11243.1"
-        str(".") >> match('\d').as(:stage_iteration)
-      end
-
-      # Sheet notation: /1:1994 (sheet 1 from year 1994)
-      # IEC 60695-2-1/1:1994
-      rule(:sheet_notation) do
-        str("/") >>
-          match('\d').repeat(1).as(:sheet_number) >>
-          str(":") >>
-          year_digits.as(:sheet_year)
-      end
-
-      # Sheet notation without year: /1 (sheet 1 without year)
-      # IEC 60695-2-1/1
-      rule(:sheet_notation_no_year) do
-        str("/") >>
-          match('\d').repeat(1).as(:sheet_number)
-      end
-
-      # Fragment notation: /FRAG2 or /FRAGC1 (fragment of amendment/corrigendum)
-      # IEC 60050-191/AMD2/FRAG2
-      # IEC 60050-191/COR1/FRAGC1
-      rule(:fragment_notation) do
-        str("/") >>
-          (str("FRAGC") | str("FRAG")).as(:fragment_type) >>
-          match('\d').repeat(1).as(:fragment_number)
-      end
-
-      # Sheet identifier: base identifier followed by /N:YEAR
-      # IEC 60695-2-1/1:1994 (sheet 1 from year 1994)
-      # IEC 60695-2-1/1 (sheet 1 without year)
-      rule(:sheet_identifier) do
-        identifier_copublishers_no_third.as(:base) >>
-          (sheet_notation | sheet_notation_no_year)
-      end
-
-      # Sheet identifier followed by supplement: base/sheet/supplement
-      # IEC 60695-2-1/1:1994/COR1:1995
-      rule(:sheet_supplement_identifier) do
-        identifier_copublishers_no_third.as(:base) >>
-          sheet_notation >>
-          str("/") >> supplement_type_with_stage >>
-          space? >> second_part >> third_part
-      end
-
-      # VAP suffix for consolidated/version types
-      # CSV = Consolidated version (with Supplements)
-      # CMV = Commented Version
-      # RLV = Redline Version (shows changes)
-      # SER = Serial version
-      # EXV = Example version
-      # PAC = Package
-      # PRV = Preview version
-      # Internal helper (no `.as`): a single VAP code. The capture key stays
-      # :vap_suffix below; this rule just lets the suffix be one or more codes.
-      rule(:vap_code) do
-        str("CSV") |
-          str("CMV") |
-          str("RLV") |
-          str("SER") |
-          str("EXV") |
-          str("PAC") |
-          str("PRV")
-      end
-
-      # One or more VAP codes joined by "-", captured whole, e.g. "CSV" or
-      # "EXV-CMV"; the builder splits it into the VapIdentifier `vap` array.
-      rule(:vap_suffix) do
-        space >> (vap_code >> (str("-") >> vap_code).repeat).as(:vap_suffix)
-      end
-
-      # Database suffix: " DB"
-      # IEC 60617:2012 DB
-      rule(:database_suffix) do
-        space >> str("DB").as(:database)
-      end
-
-      # Consolidated amendments: +AMD1:2016+AMD2:2019
-      # Also supports without dates: +AMD1+AMD2
-      # Creates ConsolidatedIdentifier with array of amendments
-      rule(:consolidated_supplement) do
-        str("+") >>
-          (str("AMD") | str("COR")).as(:supplement_type) >>
-          match('\d').repeat(1).as(:supplement_number) >>
-          (str(":") >> year_digits.as(:supplement_year)).maybe
-      end
-
-      rule(:consolidated_supplements) do
-        consolidated_supplement.repeat(1).as(:consolidated_supplements)
-      end
-
-      rule(:second_part) do
-        # Try TRF organization number first, fallback to regular number
-        (trf_org_number | number_with_part) >>
-          stage_iteration.maybe >>
-          (space? >> date).maybe >>
-          consolidated_supplements.maybe >>
-          (vap_suffix | database_suffix).maybe
-      end
-
-      rule(:third_part_edition) do
-        space? >> edition.maybe
-      end
-
-      rule(:third_part) do
-        # End of the identifier, we can have language, edition, fragment, or all parts
-        third_part_edition >> language.maybe >> fragment_notation.maybe >> all_parts.maybe
-      end
-
-      # prefix sole or copublishers with type and stage
-      # IEC/TR 60038
-      # ISO/IEC TS 20594-1
-      # IEC/FDIS 60038
-      rule(:identifier_copublishers) do
-        identifier_copublishers_no_third >> third_part
-      end
-
-      rule(:guide_prefix) do
-        str("Guide") | str("GUIDE")
-      end
-
-      rule(:identifier_copublishers_no_third) do
-        # Guide IEC 51:1999
-        (guide_prefix.as(:type_with_stage_fr) >> space).maybe >>
-          prefix_with_copublishers.maybe >> space? >> str("/").maybe >>
-          type_with_stage.maybe >>
-          space.maybe >>
-          second_part >> third_part_edition
-      end
-
-      # For joint identifiers (ISO/IEC)
-      # ISO/IEC 17025:2017 handles copublisher in copublishers rule
-      # We handle this in identifier_copublishers already
-      rule(:joint_identifier) do
-        identifier_copublishers_no_third.as(:base) >>
-          space? >> str("|") >> space? >>
-          scope { iso_identifier }.as(:joint_identifier)
-      end
-
-      rule(:iso_identifier) do
-        Pubid::Iso.joint_grammar_atom(:identifier)
-      end
-
-      rule(:supplement_type_with_stage) do
-        # "DAM"
-        # "Amd"
-        # "FRAG" (fragments of amendments)
-        # "FRAGC" (fragments of corrigenda)
-        (array_to_str(TYPED_STAGES_SUPPLEMENTS) | str("FRAGC") | str("FRAG")).as(:type_with_stage)
-      end
-
-      # Standalone draft supplement (no base identifier)
-      # IEC/FDAM 60038-1
-      # IEC/FDCOR 12345
-      rule(:standalone_supplement) do
-        prefix_with_copublishers >> str("/") >>
-          supplement_type_with_stage >>
-          space >> second_part >> third_part
-      end
-
-      # IEC 60038:2009/Amd 1:2011
-      rule(:supplement_identifier_no_third) do
-        identifier_copublishers_no_third.as(:base) >>
-          str("/") >> supplement_type_with_stage >>
-          space? >> second_part
-      end
-
-      rule(:supplement_identifier) do
-        supplement_identifier_no_third >> third_part
-      end
-
-      # IEC 60038:2009/Amd 1:2011/Cor 1:2012
-      rule(:supplement_supplement_identifier) do
-        supplement_identifier_no_third.as(:base) >>
-          str("/") >> supplement_type_with_stage >>
-          space? >> second_part >> third_part
-      end
-
-      rule(:dash) do
-        DASH_CHARS.map { |char| str(char) }.reduce(:|)
-      end
-
       IEV_SHORTHAND = /\AIEV(?=\z|[\s-])/
 
-      # Pre-parse ingestion normalizations (R2): every parse path —
-      # parslet and PG artifact alike — feeds the grammar the same
-      # normalized string.
+      # Pre-parse ingestion normalizations (R2): every parse path feeds
+      # the grammar the same normalized string.
       def self.normalize_input(input)
         # Normalize tab-separated editions: "IECEE AD-001\tED1.6" -> "IECEE AD-001 ED1.6"
         normalized = input.gsub("\t", " ")
@@ -440,10 +17,6 @@ module Pubid
         # Expand IEV shorthand: "IEV" / "IEV-351" -> "IEC 60050" / "IEC 60050-351"
         normalized.sub(IEV_SHORTHAND, "IEC 60050")
       end
-
-      def parse(input)
-        super(self.class.normalize_input(input))
-      end
     end
   end
 end

data/lib/pubid/ieee/CLAUDE.md

@@ -97,3 +97,5 @@ The lesson BSI paid for: a wrapper's hand-written `#number` delegation makes the
 - **The project designator format, and the bare-P parse that dropped it (pubid#18).** IEEE's own draft documents are cited by their short designator — "P1201/D0.3", "P10000/D1.2" — and metanorma-ieee had to post-process the full rendering to produce it. Two edits. **(1) `format: :project`** registers `Pubid::Ieee::ProjectRenderer` in the IEEE format registry: the code (with parts), a PREPENDED "P" when the identifier is a project but the code does not already carry it, and "/D<draft>"; no publisher, no type word, no date. "Project" is detected in all three places a marker can live depending on the building path — `code_obj.prefix` (the bare spelling), the "P" type code, or a `typed_stage` with `project_status` (D1-D6). **(2) The bare-P data loss**: `ieee_p_identifier` consumed its leading "P" with a bare `str("P")`, so "P1201/D0.3" parsed WITHOUT its P anywhere (the number was "1201", prefix nil) — the issue's complaint verbatim. The rule now lets `number` capture the P (the #318 pattern), so `code.prefix` survives and the designator has something to read. The DEFAULT rendering is unchanged — the corpus keeps the P in every unapproved-draft canonical, and #318's idempotence work locked that; the issue's suggestion that the default drop the P predates the corpus and is not adopted. A published (non-project) id renders its bare number under `:project` — the format is a draft-designator view.
 
 - **Joint stage-first forms are lead ISO, and the ISO face is lossless (pubid#477)**: a stage word printed in the ISO position (`IEEE FCD 15026.3:2010`, `IEEE/IEC CD2 P62582-2017-05`) parses as printed (#469): `Builder#build_joint_development` sets `lead_party "ISO"` whatever the publisher order, so `canonical_format` is `:iso`. PR #472 had made the lead the first printed publisher and rendered an IEEE-first form in the `D=` face — but the grammar artifact cannot parse most of those renders (`D=FCD`, `D=CD.2`, a non-P number, a month), and `D=CD-2020` parses into a *different* id (`ieee_draft`, no `iso_stage`), so 19 published `relaton-data-ieee` rows stopped matching themselves. The `D=` face now prints only for an id that carries a `D=` designator, or on an explicit `to_s(format: :ieee)`. `JointDevelopment#to_iso_format` prints `iso_stage` as stored (`DIS2`, `CD4` — #472's bare `CD` lost the iteration) and the date in the spelling that parses back (`#iso_date_suffix`: `:2018`, `-2018-05`, `, April 2019`). **The test is `parse(to_s) == id`, not a stable `to_s`**: a lossy render reaches a fixed point and round-trips its *hash* (`iso_stage_spellings_spec` held both while dropping `CD4`→`CD`), yet the reparse is a different identifier. Measured over the 118 joint stage rows of `relaton-data-ieee`: `to_s` stable 100 → 118, `==` 51 → 106; the other 12 carry an `ieee_draft` or an edition that the ISO face still drops. **PARG separator-in-capture, again (#471)**: the draft `revision` capture is `".12"`, and `Draft#to_s` adds its own dot, so `handle_draft` strips the leading dot (`D2022.10.12` rendered `D2022.10..12`). Check every capture a renderer re-joins with a separator. Locked by `spec/pubid/ieee/joint_stage_roundtrip_spec.rb` (stored index hashes → `parse(to_s) == row`).
+
+- **IEEE parses through the edition-2 artifact's typed model bindings (the last converter wave)**: the three `Backend.parse` sites (`identifiers/base.rb` `parse_single`, `Aiee::Identifier.parse`, `Ire::Identifier.parse`) route through `Pubid::Parg::Model.bound` — the grammar's `bindings` block produces the builder-ready hash at the engine, replacing the tree normalization. The grammar side (pubid-grammar `grammars/{ieee,nesc}.parg` edition 2 + bindings, plus a class-ref inlining pass over the merged `aiee.parg`/`ire.parg`) keeps every capture the builder reads: leaf scalars bind `(string)`; the branch/wrapper captures the builder dispatches on (`draft`, `parameters`, `publishers`, `base`, `relationship_type`, `related_ids`, the aiee/ire/nesc wrappers, …) bind `(raw)` — raw subtrees carry `Parsanol::Slice` leaves whose `to_s`/`==` behave like strings, so `extract_value` and the `.is_a?(Hash)` probes are unchanged. **Load-bearing grammar deviations** (documented in the `.parg` headers): the zero-width markers are re-spelled as real-token captures (`printed_dash_year`/`printed_month_year` capture their branch's leading separator, `iec_label_dash` the dash, `iso_published` the whole joint head choice — every read sits behind a nil-`iso_stage` gate, so the wider presence set is inert exactly where v1's was narrow); the `([dash]) as draft_dash` / `([rev_sep] as rev_sep)` capture-over-OPTIONAL landmines are `[ (x) as y ]` (parsanol-ruby#394); nested-only captures that collide with a top-level name rename with the builder (`draft_date_month/year/day`, `draft_version_dash_*`, `fdraft_month/year`, and `reaffirmed_year` — unbound, because binding it would have surfaced the reaffirmation year v1 kept absent). **Class RULE refs (`digit`/`lower`/`upper`, and multi-char ones like `alnum_char`/`identifier_string`'s `non_nl`) materialize per-token named nodes inside captures when the runtime recompiles the `use`-importing source — the vendored `data/parg/{aiee,ire,nesc}.parg` copies are the live import sources, so they must be re-vendored together with the artifacts** (a stale `.parg` beside a fresh `.json` silently parses through the old grammar). **Builder accommodations** (all dual-key with the v1 spellings as fallback, so HEAD trees and bound maps read alike): the renamed nested keys; and the multi-segment draft-version normalization at the top of `build_single_identifier` — edition-2 trees materialize a "D2.1.1" designator as per-token nodes with no `:draft_version`, where v1 degraded to a whole-clause leaf (reconstructed: the leaf string → `Draft.parse` inverse) or to a date-only hash when a draft date follows (no draft built). **Measured**: fixture-corpus parity (old artifact + tree backend + builder vs new artifact + bound + builder) over all 9,054 pass-fixture inputs → 1 diff, and standalone aiee/ire/nesc sweeps → 0 diffs each. **The one residue is an engine wall, documented not chased**: `IEC/IEEE PC37.60/P62271-111_D6.1` (testsuite case `ieee.project_draft_identifier.0946`, one corpus input, one `draft_compact_convergence` example) — v1's edition-1 tree degraded its whole draft clause ("DP62271-111_D6.1, Aug 2016", two P-numbers plus date) into a single leaf, and edition-2's fully-named trees cannot reproduce that collapse at any binding spelling (isolated rule probes + programmatic branch bisect); the row is one of the two-P-number joint one-offs already recorded as deferred above. The conversion also **fixed** two testsuite rows (`ieee.project_draft_identifier.9263` "ISO/IEC/IEEE P42010.2019/D4" / "P42010.WD4:2019(E)" — the lettered `draft_iso_iteration` capture now binds, so the D= face composes), at the cost of the 0946 residue above.

data/lib/pubid/ieee/aiee/identifier.rb

@@ -35,7 +35,8 @@ module Pubid
 
         # Parse AIEE identifier string
         def self.parse(input)
-          parsed = Parser.new.parse(input)
+          parsed = Pubid::Parg::Model.bound(:aiee, input,
+                                    entry: "aiee_identifier")
           Builder.new.build(parsed)
         end
 

data/lib/pubid/ieee/aiee.rb

@@ -5,7 +5,6 @@ module Pubid
     module Aiee
       autoload :Builder, "#{__dir__}/aiee/builder"
       autoload :Identifier, "#{__dir__}/aiee/identifier"
-      autoload :Parser, "#{__dir__}/aiee/parser"
     end
   end
 end