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

data/lib/pubid/ieee/components/code.rb

@@ -16,6 +16,8 @@ module Pubid
       # +original_separator+ to round-trip dot vs dash notation, and uses
       # +number+ rather than +value+.
       class Code < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :prefix, :string             # C, P for some identifiers
         attribute :number, :string             # Main number (802, 1234, etc.)
         attribute :parts, :string, collection: true # Array of part strings

data/lib/pubid/ieee/components/draft.rb

@@ -11,6 +11,8 @@ module Pubid
       #   /D3.4            - version with revision
       #   /D7, July 2019   - with date
       class Draft < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :version, :string       # D5, D3, etc.
         attribute :revision, :string      # .4, .2 in D3.4
         attribute :year, :string
@@ -20,6 +22,11 @@ module Pubid
         attribute :comma_before_month, :boolean, default: -> {
           false
         } # Track if comma was in input
+        # The joint stage-draft half of the compound form "D5=DDIS.3":
+        # the ISO/IEC stage this draft iterates (DIS) and its iteration
+        # numeral (3). See docs/IEEE-DRAFT-STAGES.md §1.3.
+        attribute :iso_stage, :string
+        attribute :iso_iteration, :string
 
         # Month name to number mapping
         MONTH_NAMES = {
@@ -32,7 +39,7 @@ module Pubid
         }.freeze
 
         def initialize(version: nil, revision: nil, year: nil, month: nil,
-day: nil)
+day: nil, iso_stage: nil, iso_iteration: nil)
           super()
           self.version = version
           self.revision = revision
@@ -40,6 +47,15 @@ day: nil)
           self.original_month = month # Store original format
           self.month = convert_month(month)
           self.day = day
+          # The grammar's ordered alternation captures the stage WITH its
+          # draft-marker D when the spelling doubles it ("=DDIS"): the
+          # marker is notation, the stage is the bare ISO/IEC token.
+          if iso_stage.to_s.start_with?("D") &&
+             %w[PWI NP WD CD CDV DIS FDIS].include?(iso_stage[1..])
+            iso_stage = iso_stage[1..]
+          end
+          self.iso_stage = iso_stage
+          self.iso_iteration = iso_iteration
         end
 
         # Month names as an alternation, longest-first so "September" wins over
@@ -61,12 +77,27 @@ day: nil)
         # this method after `from_hash` (a mismatch breaks `to_hash` round-trip).
         # @param value [String, Draft] the value to coerce
         # @return [Draft]
+        # The compound stage suffix (docs/IEEE-DRAFT-STAGES.md §1.3):
+        # "=DIS.3" is canonical — D (draft) = DIS (the stage), iteration 3.
+        # "=DDIS.3", "=DDIS3", "=DDIS-3" (the stage echoed with its own D)
+        # are accepted aliases. Captures [stage, iteration].
+        COMPOUND_SUFFIX = /=D?(PWI|NP|WD|CDV|FDIS|DIS|CD)(?:[.-]?(\d+))?\z/.freeze
+        private_constant :COMPOUND_SUFFIX
+
         def self.parse(value)
           return value if value.is_a?(Draft)
 
           body = strip_prefix(value.to_s)
+          iso_stage = nil
+          iso_iteration = nil
+          if (m = body.match(COMPOUND_SUFFIX))
+            iso_stage = m[1]
+            iso_iteration = m[2]
+            body = body[0...m.begin(0)]
+          end
           version, month, day, year, comma = split_date(body)
-          draft = new(version: version, month: month, day: day, year: year)
+          draft = new(version: version, month: month, day: day, year: year,
+                      iso_stage: iso_stage, iso_iteration: iso_iteration)
           draft.comma_before_month = comma
           draft
         end
@@ -110,6 +141,8 @@ day: nil)
 
         def to_s
           result = "/D#{version}"
+          result += "=#{iso_stage}" if iso_stage
+          result += ".#{iso_iteration}" if iso_stage && iso_iteration
           result += ".#{revision}" if revision
 
           if year

data/lib/pubid/ieee/components/typed_stage.rb

@@ -19,6 +19,8 @@ module Pubid
       # - Approved Draft: Board-approved but unpublished (D7-D9)
       # - Published: Final standards (no P prefix)
       class TypedStage < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         # All recognized abbreviations for this stage
         # First in array is canonical abbreviation
         attribute :abbr, :string, collection: true

data/lib/pubid/ieee/identifiers/base.rb

@@ -201,6 +201,18 @@ module Pubid
         hash
       end
 
+      # Three more IEEE discriminators the default %i[date year edition
+      # version] list misses, alongside `edition`/`year`: `revision` (e.g.
+      # "2" in "P802.16Rev2"); `reaffirmed` (the "(R2010)" year, read by
+      # renderer.rb and urn_generator.rb — two reaffirmations of the same
+      # standard failed to collapse under #to_all_parts/#===); and
+      # `edition_month`, the month half of "Edition N YYYY-MM"
+      # (renderer.rb's `"Edition #{edition} #{year}-#{edition_month}"`),
+      # which survived even though its sibling `year` is already stripped.
+      def self.all_parts_edition_keys
+        super + %i[revision reaffirmed edition_month]
+      end
+
       # Inverse of the to_hash compaction: expand a scalar `stage` back into the
       # `typed_stage` sub-hash (on a deep copy, recursively) before lutaml
       # deserializes, so nested bases rebuild their component too. `draft` needs
@@ -351,7 +363,15 @@ module Pubid
       def self.parse_single(input)
         # Apply legacy update_codes normalization first, before Parser's extensive preprocessing
         normalized = Core::UpdateCodes.apply(input, :ieee)
-        parsed = Parser.parse(normalized) # Use class method for preprocessing
+        # UpdateCodes may introduce the "; " double-label separator
+        # ("ISO/IEC13210: 1994 (E) ANSI/IEEE Std ..." → the ISO/IEC and
+        # IEEE labels of one document), but the dispatch ran on the raw
+        # input - re-dispatch so the dual construction sees it.
+        if normalized != input && normalized.include?("; ")
+          result = PreParser.preprocess(normalized)
+          return build_dual(result.parts) if result.dispatch == :dual_semicolon
+        end
+        parsed = Pubid::Parg::Backend.parse(:ieee, Parser.normalize_input(normalized))
         builder = Builder.new(Identifier)
         # Pass the original input string to builder for context
         builder.original_input = input

data/lib/pubid/ieee/identifiers/iec_ieee_copublished.rb

@@ -26,6 +26,15 @@ module Pubid
         attribute :iec_year, :string            # IEC year like "2013"
         attribute :date_info, :string           # Date information like "(10/07)"
 
+        # `year_sep` only describes how a year is attached. When the reference
+        # omits the year, a subset match skips it: its default "-" would
+        # otherwise refuse a candidate printed with ":".
+        def subset_attribute_match?(name, mine, theirs)
+          return true if name == :year_sep && year.nil?
+
+          super
+        end
+
         # The printed IEC/IEEE number, rebuilt losslessly from the split
         # columns (the renderer/urn read this). Not stored — number/parts/
         # separators/year fully describe it, so the verbatim string never

data/lib/pubid/ieee/identifiers/joint_development.rb

@@ -42,6 +42,8 @@ module Pubid
         attribute :year, :string
         attribute :iso_stage, :string               # For ISO stage if present
         attribute :ieee_draft, :string              # For IEEE P/D notation if present
+        attribute :parenthetical_content, :string   # e.g. the "(E)" edition
+                                                    # marker of an ISO/IEC label
 
         # Accepts keyword args or a single positional hash (the base
         # #exclude/matching rebuild passes the latter) — see
@@ -77,6 +79,11 @@ module Pubid
         # Canonical format based on lead party
         # @return [Symbol] :ieee or :iso
         def canonical_format
+          # A stage-tracked D= designator is IEEE draft notation — its
+          # canonical face is the designator spelling (§1.3 spelling 7:
+          # "JOINT PNUMBER/D=<STAGE>[:year]"), whatever the lead party.
+          return :ieee if ieee_draft.to_s.start_with?("D=")
+
           case lead_party
           when "IEEE", "AIEE"
             :ieee
@@ -128,24 +135,44 @@ module Pubid
           # Publishers (slash-separated)
           parts << publishers.join("/") if publishers && !publishers.empty?
 
-          # ISO stage code (only if this was originally ISO-led)
-          # For IEEE-led conversions, we skip the stage since we don't have ISO equivalent
-          if lead_party == "ISO" && (typed_stage || iso_stage)
-            if typed_stage
-              parts << typed_stage.to_iso_format
-            elsif iso_stage
-              parts << iso_stage
-            end
+          # The stage word is the ISO format's own position convention —
+          # it prints whenever the identifier carries one, regardless of
+          # lead party (the format face decides, not the arrangement). A
+          # stage-tracked D= designator decomposes into its stage word
+          # and date ("D=CD.2-2020" → "CD2", 2020); the iteration glues
+          # onto the word only for the stages whose printed ISO spellings
+          # carry it (CD2, DIS2 — the grammar's multi-digit families);
+          # the P project stage is IEEE convention and never prints here.
+          # The printed word is always the bare stage ("CD4" prints "CD",
+          # "DIS3" prints "DIS" — every iso_stage_spellings_spec
+          # expectation); the iteration is draft machinery, not ISO-face
+          # identity.
+          stage_word = iso_stage.to_s.sub(/\A([A-Z]+?)\d+\z/, '\1')
+          stage_word = nil if stage_word.empty?
+          draft_year = nil
+          if stage_word.nil? &&
+             ieee_draft.to_s.match(/\AD=([A-Z]+)(?:\.(\d+[a-z]?))?(?:[-:](\d{4}))?\z/)
+            stage_word = Regexp.last_match(1)
+            draft_year = Regexp.last_match(3)
           end
+          parts << stage_word if stage_word
 
-          # Code (NO P prefix in ISO format, NO draft notation)
-          code_str = code.to_s.gsub(/^P/, "")
+          # The P project marker is identity-bearing and prints on both
+          # faces (the standing trademark_leaf_to_s_spec contract:
+          # "ISO/IEC/IEEE P26511:2018").
+          code_str = code.to_s
           code_str += mark unless code_str.empty?
           parts << code_str if code_str && !code_str.empty?
 
-          # Join with space and add year with colon
+          # Join with space and add year with colon (the ISO position
+          # convention; a decomposed D= date rides here as the year).
           result = parts.join(" ")
-          result += ":#{year}" if year
+          result += ":#{year || draft_year}" if year || draft_year
+          # Only the language/edition marker ("(E)", "(E/F)") prints; a
+          # trailing relationship narrative is metadata, not identity.
+          if parenthetical_content&.match?(%r{\A[A-Z](?:\s*[/&]\s*[A-Z])*\z})
+            result += " (#{parenthetical_content})"
+          end
 
           result
         end
@@ -159,29 +186,45 @@ module Pubid
           # Publishers (slash-separated)
           parts << publishers.join("/") if publishers && !publishers.empty?
 
-          # Build code part
-          code_str = code.to_s.gsub(/^P/, "") # Remove any existing P first
-
-          # Add P prefix for projects (IEEE format always shows P for drafts)
-          if typed_stage&.project_status || type == "P"
-            code_str = "P#{code_str}"
-          end
+          # Build code part — the P-state prints as spelled (P = project
+          # draft; no P = standard). Never added or stripped.
+          code_str = code.to_s
 
           # Mark after the number, before the draft and the year
           code_str += mark unless code_str.empty?
 
-          # Add IEEE draft notation if available (e.g., /D8)
-          if ieee_draft
+          # Add IEEE draft notation if available (e.g., /D8). An ISO stage
+          # word renders in IEEE's stage-tracked position as the ordinal-less
+          # stage draft (docs/IEEE-DRAFT-STAGES.md §1.3, spelling 7):
+          # "IEEE/ISO/IEC CD P42010:2020" → "IEEE/ISO/IEC P42010/D=CD-2020".
+          # The iso_stage branch is checked FIRST — the typed_stage registry
+          # lookup for a stage word answers a draft-equivalent ordinal ("D2"),
+          # which is not the canonical stage-tracked spelling.
+          if ieee_draft.to_s.start_with?("D=") && year
+            # The ordinal-less stage draft's canonical face (the
+            # UpdateCodes rewrite): the publication year colon-joins the
+            # code and the designator trails — "P16326:2017/D=WD.5".
+            code_str += ":#{year}"
+            code_str += "/#{ieee_draft}"
+            @designator_carries_year = true
+          elsif ieee_draft
             code_str += "/#{ieee_draft}"
+          elsif iso_stage
+            # The ordinal-less stage draft: an iteration glued onto the
+            # printed word ("CD2") renders in the doctrine's ".iter" slot
+            # ("D=CD.2" — docs/IEEE-DRAFT-STAGES.md §1.3).
+            stage = iso_stage.match(/\A([A-Z]+?)(\d+)\z/)
+            code_str += stage ? "/D=#{stage[1]}.#{stage[2]}" : "/D=#{iso_stage}"
           elsif typed_stage&.ieee_draft_equivalent
             code_str += "/#{typed_stage.ieee_draft_equivalent}"
           end
 
           parts << code_str if code_str && !code_str.empty?
 
-          # Join with space and add year with dash
+          # Join with space and add year with dash — unless the D=
+          # designator face already carried it above.
           result = parts.join(" ")
-          result += "-#{year}" if year
+          result += "-#{year}" if year && !@designator_carries_year
 
           result
         end

data/lib/pubid/ieee/identifiers/project_draft_identifier.rb

@@ -33,10 +33,17 @@ module Pubid
         # object. The "P" is reflected in the typed_stage, not in the Code
         # component itself. Accepts keyword args or a single positional hash (the
         # base #exclude/matching rebuild passes the latter).
+        attribute :project_marker, :boolean, default: -> { false }
+
         def initialize(args = {}, **kwargs)
           args = kwargs.empty? ? args.dup : args.merge(kwargs)
-          # If code is provided with "P" prefix (e.g., "P1234"), strip it
+          # If code is provided with "P" prefix (e.g., "P1234"), strip it.
+          # P = project (the document is a draft): the marker is
+          # identity-bearing, so its presence is remembered for the render —
+          # stripping the letter must not strip the fact (docs/
+          # IEEE-DRAFT-STAGES.md §1.1).
           if args[:code].is_a?(String) && args[:code].start_with?("P")
+            args[:project_marker] = true unless args.key?(:project_marker)
             args[:code] = args[:code][1..] # Strip leading "P"
           end
 

data/lib/pubid/ieee/parser.rb

@@ -269,6 +269,10 @@ module Pubid
       rule(:draft_date) do
         # Enhanced to handle: ", Sept 2008" or " Sept 2008" or ", Month Year"
         ((comma | space) >> month_name.as(:month) >> space >> year_digits.as(:year)) |
+          # Space-separated bare year after the draft designator
+          # ("IEEE Draft Std P14764/D1 2004, Nov 2004" - the "D1 2004" draft
+          # carries its own year, with the print date still trailing).
+          (space >> year_digits.as(:year)) |
           # Numeric-month form ", 05 2007" / " 05 2007" — no text month name. The
           # year separator may be a dash: preprocessing (parser.rb ~1278) rewrites
           # a trailing " <digits> <year>" to "<digits>-<year>", so "05 2007"
@@ -302,6 +306,15 @@ module Pubid
       rule(:draft) do
         (draft_prefix >> draft_version.repeat(1, 2) >>
          (dot >> digits.as(:revision)).maybe >>
+         # The compound both-systems form (docs/IEEE-DRAFT-STAGES.md
+         # §1.3): "=DDIS.3" - IEEE draft ordinal = draft of the ISO/IEC
+         # stage, with its iteration. The glued "=DDIS3" / "=DDIS-3"
+         # spellings are accepted aliases of "=DDIS.3".
+         (str("=") >> (str("D") >> (str("FDIS") | str("CDV") | str("PWI") |
+            str("DIS") | str("WD") | str("NP") | str("CD")) |
+           (str("FDIS") | str("CDV") | str("PWI") | str("DIS") | str("WD") |
+            str("NP") | str("CD"))).as(:draft_iso_stage) >>
+           (dot | dash).maybe >> digits.as(:draft_iso_iteration).maybe).maybe >>
          draft_date.maybe).as(:draft)
       end
 
@@ -532,7 +545,9 @@ module Pubid
 
       # Additional parameters (inside parentheses)
       rule(:additional_parameters) do
-        (space.maybe >> str("(") >> # Make space before '(' optional
+        (space.maybe >> str("(") >> space.maybe >> # Space before/after '(' optional
+         # ("( Revision of …)" - a crawl space inside the paren must not push
+         # the narrative to the catch-all and into the render).
          (reaffirmed |
           # Handle "Revision of IEEE Std ..." with optional space after Std
           (str("Revision of IEEE Std ") >> space.maybe >> match("[^)]").repeat(1).as(:revision_of)) |
@@ -580,17 +595,42 @@ module Pubid
         # ISO/IEC/IEEE P26511/D8-2018 or ISO/IEEE P1003.1-2008 or IEC/IEEE P62582-1-2011
         # ALSO handle: IEC/IEEE P60780-323, CDV1 2014 (comma before stage code)
         # ALSO handle: IEEE/CSA P844.1/293.1/D2 (CSA dual numbering)
-        (str("ISO/IEC/IEEE") | str("ISO/IEEE") | str("IEC/IEEE") | str("IEEE/CSA")).as(:joint_publishers) >>
+        # ALSO handle: IEEE/ISO/IEC P42010/D=CD-2020 — the printed publisher
+        # order is the organization's perspective (pubid#469) and parses as
+        # printed; it is no longer rewritten to ISO-first.
+        (str("ISO/IEC/IEEE") | str("IEEE/ISO/IEC") | str("ISO/IEEE") | str("IEC/IEEE") | str("IEEE/CSA")).as(:joint_publishers) >>
           space >>
-          str("P") >> # P indicates IEEE-led
+          # P = project (the document is a draft): identity-bearing, so it
+          # is captured and preserved, never silently consumed.
+          str("P").as(:project_marker) >>
           digits.as(:number) >>
           ((dot | dash) >> digits.as(:part)).maybe >> # Optional part like .1 or -1
           # CSA dual numbering: /293.1 (second number)
           (slash >> digits >> (dot >> digits).maybe >> (dash >> digits.as(:draft_version)).maybe).maybe >>
           (
-            # Variant 1: /D8 notation (original)
-            (slash >> str("D") >> digits.as(:draft_version)) |
-            # Variant 2: , CDV1 notation (comma before stage code)
+            # Variant 1b: the ordinal-less stage draft "D=CDV-2020" -
+            # D (draft) = CDV (the IEC stage it drafts). The year rides in
+            # the draft clause (a distinct key, so the builder keeps the
+            # date inside the designator). The year follows IEEE format:
+            # dash-joined ("D=CD-2020", the ruled canonical); the colon
+            # spelling ("D=CDV:2020") stays accepted as the alias it was
+            # frozen with. A dash-year is guarded to 19xx/20xx so a
+            # YYMM monthcode tail can never be read as a year.
+            (slash >> str("D") >> str("=") >>
+              (str("CDV") | str("FDIS") | str("PWI") | str("WD") |
+               str("NP") | str("DIS") | str("CD")).as(:draft_iso_stage) >>
+              ((str(":") | str("-")) >>
+               ((str("19") | str("20")) >> digit >> digit).as(:draft_stage_year)).maybe) |
+            # Variant 1: /D8 notation (original), with the compound
+            # both-systems suffix "=DDIS.3" (docs/IEEE-DRAFT-STAGES.md §1.3)
+            (slash >> str("D") >> digits.as(:draft_version) >>
+              (str("=") >> (str("D") >> (str("FDIS") | str("CDV") | str("PWI") |
+                 str("DIS") | str("WD") | str("NP") | str("CD")) |
+               (str("FDIS") | str("CDV") | str("PWI") | str("DIS") | str("WD") |
+                str("NP") | str("CD"))).as(:draft_iso_stage) >>
+               (dot | dash).maybe >> digits.as(:draft_iso_iteration).maybe).maybe) |
+            # Variant 2: , CDV1 notation (comma before stage code) —
+            # the stage draft of the named ISO/IEC stage, its iteration
             (comma >> (str("CDV") | str("FDIS") | str("CD") | str("DIS")).as(:iec_stage) >> digits.maybe.as(:stage_iteration))
           ).maybe >>
           # Optional edition, from relaton's "/E-<n>" suffix normalized to
@@ -636,18 +676,30 @@ module Pubid
             str("").as(:iso_published) >> space.maybe)) |
           (staged_only.as(:joint_publishers) >> space >>
             iso_stage >> std_noise >> space)) >>
-          str("P").maybe >> # optional project marker on the number
+          str("P").as(:project_marker).maybe >> # project marker (P =
+                                                # project/draft; its
+                                                # presence is identity)
           digits.as(:number) >>
-          # part must not swallow the trailing year (year_digits.absent?)
-          ((dot | dash) >> year_digits.absent? >> digits.as(:part)).maybe >>
+          # part must not swallow the trailing year (year_digits.absent?). A
+          # DASH-joined part is tagged (:part_dash) - the catalogue-printed
+          # joint form spells the part with a dash ("21451-7") where the ISO
+          # form uses the dot.
+          ((dot >> year_digits.absent? >> digits.as(:part)) |
+           (dash >> str("").as(:part_dash) >> year_digits.absent? >>
+             digits.as(:part))).maybe >>
           (
             (str(":") >> year_digits.as(:year)) |
+            # The dash-year (and ", Month YYYY" text date below) spellings are
+            # the catalogue-PRINTED joint form; tag them (:printed_form) so the
+            # builder routes to a Standard instead of the ISO joint reference.
             (dash >> year_digits.as(:year) >>
-             (dash >> month_numeric.as(:month)).maybe) |
+             (dash >> month_numeric.as(:month)).maybe >>
+             str("").as(:printed_dash_year)) |
             # Trailing text date ", April 2015" / " April 2015" (build_joint_development
             # already reads :month/:year). No :year collision — the iso rule has no
             # other :year capture (edition uses :edition_year).
-            ((comma | space) >> month_name.as(:month) >> space >> year_digits.as(:year))
+            ((comma | space) >> month_name.as(:month) >> space >>
+             year_digits.as(:year) >> str("").as(:printed_month_year))
           ).maybe >>
           # Optional /D<draft> tail. normalize_relaton_suffixes repositions the
           # historical "…/D-3-2017" onto the number as "…-2017/D3", so by the
@@ -658,11 +710,26 @@ module Pubid
           # keys (:draft_month/:draft_year), because a plain :month/:year
           # here collides with the date clause above and parslet drops the
           # subtree with a "Duplicate subtrees" warning.
+          # The ISO/IEC edition marker may sit between the year and an
+          # amendment/draft tail: "8802.11:2012 (E)/Amd 1-2014". A distinct
+          # key - a second :parameters capture here collides with the
+          # trailing parenthetical slot (parslet drops duplicate subtrees).
+          (space.maybe >> str("(") >>
+           match("[^)]").repeat(1).as(:edition_marker) >> str(")")).maybe >>
+          # The stage-draft clause of the ISO-led print: "/D=WD.5" -
+          # D (draft) = the ISO/IEC stage it drafts, with its iteration
+          # (docs/IEEE-DRAFT-STAGES.md §1.2).
+          ((slash >> str("D") >> str("=") >>
+           (str("FDIS") | str("FCD") | str("CDV") |
+            (str("DIS") >> digit.maybe) |
+            (str("CD") >> digit.maybe) |
+            str("WD") | str("PWI") | str("NP")).as(:draft_iso_stage) >>
+           (dot >> (digits >> match("[A-Za-z]").repeat(0, 1)).as(:draft_iso_iteration)).maybe) |
           (slash >> str("D") >> dash.maybe >>
            match('[0-9.]').repeat(1).as(:draft_version) >>
            (((comma | space) >> month_name.as(:draft_month) >> space >>
                year_digits.as(:draft_year)) |
-             (comma >> year_digits.as(:draft_year))).maybe).maybe >>
+             (comma >> year_digits.as(:draft_year))).maybe).maybe).maybe >>
           # Optional amendment tail (pubid#317:
           # "8802-11:2012/Amd.1:2014(E)") - the flat tree keys reuse
           # build_flat_amendment.
@@ -678,7 +745,6 @@ module Pubid
           # The crawl sometimes spaces it ("…(E), January 2017" family,
           # pubid#216), and a relationship parenthetical may follow
           # ("…CD2 P15288-2013-09 (Revision of …)").
-          space.maybe >> (str("(E)") | str("(F)")).maybe >>
           parenthetical.maybe
       end
 
@@ -692,6 +758,28 @@ module Pubid
       # the trailing `.FDIS` is the ISO stage, NOT a second part. Routes through
       # the same build_joint_development (via :joint_publishers/:iso_stage), so the
       # stage is modeled correctly and the numeric part stays separate.
+      # The stage-less ISO/IEC label with a colon year and the ISO/IEC
+      # edition marker: "ISO/IEC 13210:1994 (E)" - the ISO/IEC portion of a
+      # double-labeled standard. The (E) parenthetical is REQUIRED: without
+      # it this spelling is the ISO flavor's own form and must not be
+      # stolen. Routes through build_joint_development like every ISO-led
+      # joint reference.
+      rule(:joint_development_iso_iec_edition) do
+        str("ISO/IEC").as(:joint_publishers) >> space >>
+          str("").as(:iso_published) >>
+          str("P").as(:project_marker).maybe >>
+          digits.as(:number) >>
+          # The part may be dot- or dash-joined ("8802-9"); a dash-year
+          # ("1234-2012") is not a part.
+          # A distinct key: the iso-format route's :part_dash prints as a
+          # dot in the joint code (the "P24748.2:2018" convention); only
+          # the ISO/IEC LABEL keeps its printed dash.
+          ((dot | (dash >> str("").as(:iec_label_dash) >> year_digits.absent?)) >>
+            digits.as(:part)).maybe >>
+          (str(":") >> space.maybe >> year_digits.as(:year)) >>
+          space.maybe >> parenthetical
+      end
+
       rule(:joint_development_embedded_stage) do
         # publisher set mirrors joint_development_iso_format (incl. bare IEEE);
         # longest token first.
@@ -699,7 +787,9 @@ module Pubid
          str("ISO/IEEE") | str("IEC/IEEE") | str("IEEE/IEC") | str("ISO/IEC") |
          str("IEEE")).as(:joint_publishers) >>
           space >>
-          str("P").maybe >> # optional project marker on the number
+          str("P").as(:project_marker).maybe >> # project marker (P =
+                                                # project/draft; its
+                                                # presence is identity)
           digits.as(:number) >>
           # optional numeric part (dot or dash); must not swallow a year
           ((dot | dash) >> year_digits.absent? >> digits.as(:part)).maybe >>
@@ -814,7 +904,17 @@ module Pubid
           ((space >> month_name.as(:trailing_month) >> space >> year_digits.as(:trailing_year)) |
            (space >> month_numeric.as(:trailing_month) >> (space | dash) >> year_digits.as(:trailing_year))).maybe >>
           draft.maybe >>
+          # A print date may trail a draft that carries its own date
+          # ("IEEE Unapproved Draft 24765/D1 2009, Oct 2009" - the draft's
+          # year is "2009", the print date is ", Oct 2009").
+          (comma >> space? >> month_name.as(:trailing_month) >> space >>
+            year_digits.as(:trailing_year)).maybe >>
           revision_suffix.maybe >>
+          # …and the print date may also trail the repositioned revision
+          # ("IEEE Unapproved Draft P802.16Rev2/D9a, March 2009" reaches the
+          # grammar as "…/D9a/R-2, March 2009" via normalize_revision_notation).
+          (comma >> space? >> month_name.as(:trailing_month) >> space >>
+            year_digits.as(:trailing_year)).maybe >>
           # Trailing corrigendum after the draft ("…/D2.0/Cor. 1", or
           # "…/D1.0, Dec 2007/Cor. 1" where the draft's own draft_date consumes
           # the date, leaving "/Cor. N"). The flat corrigendum+draft tree (no
@@ -899,10 +999,17 @@ module Pubid
           # Draft NESC pattern
           (str("Draft") >> space >> (str("NESC") | str("National Electrical Safety Code"))) |
           # Name-first pattern (NEW)
-          (str("National Electrical Safety Code") >> str(",") >> space >> str("C2-"))
+          (str("National Electrical Safety Code") >> str(",") >> space >> str("C2-")) |
+          # Catalogue form: "IEEE Std YYYY NESC ..." / "IEEE Std YYYY National
+          # Electrical Safety Code" - the prefix is consumed here (the NESC
+          # renderer prepends "IEEE Std" itself) but must not fall through to
+          # the generic standard grammar, which would read YYYY as a number.
+          (str("IEEE") >> space >> str("Std") >> space >> year_digits >> space >>
+            (str("NESC") | str("National Electrical Safety Code")))
         ).present? >>
           # Delegate to NESC parser if pattern detected
-          Nesc::Parser.new.nesc_identifier.as(:nesc)
+          ((str("IEEE") >> space >> str("Std") >> space).maybe >>
+            Nesc::Parser.new.nesc_identifier).as(:nesc)
       end
 
       # Draft notation for PSI (e.g., /D2, /D3, rawbib's /D-2)
@@ -1056,13 +1163,13 @@ module Pubid
           str("CSA") >> space >>
           # CSA number formats (various patterns observed)
           (
-            # Format 1: C22.2 No. 293.1-17 (with NO.)
-            (str("C") >> digit.repeat(2) >> dot >> digit >> space >> str("No") >> dot >> space >>
+            # Format 1: C22.2 No. 293.1-17 (with NO., either case)
+            (str("C") >> digit.repeat(2) >> dot >> digit >> space >> (str("No") | str("NO")) >> dot >> space >>
              match("[0-9.]").repeat(1) >> (dash | str(":")) >> digit.repeat(2)) |
             # Format 2: C293.2-17 (without NO., dash year)
             (str("C") >> match("[0-9.]").repeat(1) >> dash >> digit.repeat(2)) |
-            # Format 3: C22.2 No. 293.3:19 (with NO., colon year)
-            (str("C") >> digit.repeat(2) >> dot >> digit >> space >> str("No") >> dot >> space >>
+            # Format 3: C22.2 No. 293.3:19 (with NO., either case, colon year)
+            (str("C") >> digit.repeat(2) >> dot >> digit >> space >> (str("No") | str("NO")) >> dot >> space >>
              match("[0-9.]").repeat(1) >> str(":") >> digit.repeat(2)) |
             # Format 4: C293.4:19 (without NO., colon year)
             (str("C") >> match("[0-9.]").repeat(1) >> str(":") >> digit.repeat(2))
@@ -1085,6 +1192,8 @@ module Pubid
           conformance_identifier | # NEW: Try conformance identifier before generic patterns
           joint_development_ieee_format |
           joint_development_iso_format |
+          joint_development_iso_iec_edition | # stage-less ISO/IEC label with (E) - double-label portion
+
           joint_development_embedded_stage | # stage-LAST embedded form (before generic)
           iec_ieee_copublished |
           number_first_identifier |
@@ -1110,6 +1219,15 @@ module Pubid
           # never collides with the base -YYYY identity year (see
           # ieee_p_identifier). The builder promotes it only when no base year.
           trailing_month_year.maybe >>
+          # The ASHRAE joint suffix may also trail a draft+date
+          # ("IEEE P1635/D13, December, 2017/ASHRAE Guideline 21"), so a
+          # second slot catches it after the date.
+          ashrae_copub.maybe >>
+          # A bracketed narrative may sit between the base and a trailing
+          # corrigendum: "IEEE Std 671-1985 [Corrigendum to IEEE Std 671-1985
+          # (Reaff 2008)]/Cor. 1-2010" captures the bracket as the base's
+          # nickname before the wrapper is parsed.
+          book_nickname.maybe >>
           # Trailing corrigendum after the draft+date ("IEEE Approved P1015/D1,
           # Jan 2007/Cor. 1"): the generic bucket is the only path a status-word
           # form reaches. Routes via build_flat_corrigendum (disjoint from the
@@ -1333,9 +1451,12 @@ module Pubid
         # Slash-stage carrying a dash-date ("…P15288/CD2-2013-09 …" — the
         # dash-year tail is what the joint grammar reads after the number, so
         # this cannot steal the plain "/FDIS, June 2021" spellings
-        # ieee_p_identifier finishes): → "…CD2 P15288-2013-09 …"
+        # ieee_p_identifier finishes): → "…CD2 P15288-2013-09 …". The date
+        # must be a plausible year — a 4-digit monthcode (YYMM, e.g.
+        # "…P24748-4/DIS-1404" = April 2014) is a DRAFT designator, not a
+        # dash-date, and rewriting it onto the number breaks the parse.
         cleaned = cleaned.sub(
-          %r{\A#{pubs}#{num}/ ?#{stage}(-\d{4}(?:-\d\d)?)},
+          %r{\A#{pubs}#{num}/ ?#{stage}(-(?:19|20)\d\d(?:-\d\d)?)},
           '\1\3 \2\4',
         )
 
@@ -1355,7 +1476,10 @@ module Pubid
         cleaned
       end
 
-      def self.parse(string)
+      # Pre-parse ingestion normalizations (R2): every parse path —
+      # parslet and PG artifact alike — feeds the grammar the same
+      # normalized string.
+      def self.normalize_input(string)
         # Strip .pdf extension if present (Pattern 3: File Extensions)
         cleaned = string.sub(/\.pdf$/i, "")
 
@@ -1709,11 +1833,10 @@ module Pubid
         # Fix 2H: "IEC XXXX First edition YYYY-MM; IEEE NNNN" -> normalize semicolon
         # Already handled by earlier semicolon normalization
 
-        # Fix 2I: "IEEE/ISO/IEC PXXX/DIS" -> normalize to "ISO/IEC/IEEE PXXX/DIS"
-        cleaned = cleaned.gsub(/^IEEE\/ISO\/IEC\s+(P[\w.-]+)/,
-                               'ISO/IEC/IEEE \1')
-        cleaned = cleaned.gsub(/^IEEE\/IEC\/ISO\s+(P[\w.-]+)/,
-                               'IEC/ISO/IEEE \1')
+        # (Fix 2I removed: "IEEE/ISO/IEC PXXX/…" is no longer rewritten to
+        # ISO-first — the printed publisher order is the organization's
+        # perspective (pubid#469) and the joint P-form rule parses it as
+        # printed.)
 
         # Fix 2J: "IEEE/IEC PXXX D5" -> normalize space to slash before D
         cleaned = cleaned.gsub(/^(IEEE\/IEC P[\w.-]+)\s+D(\d)/, '\1/D\2')
@@ -1812,7 +1935,11 @@ module Pubid
         # Fix 2AF: "IEEE Std 1003.1/2003.l/lNT" -> fix typos
         # .l -> .1 and lNT -> INT handled by existing fixes
 
-        new.parse(cleaned)
+        cleaned
+      end
+
+      def self.parse(string)
+        new.parse(normalize_input(string))
       end
     end
   end