pubid 2.0.2 → 2.0.3

data/lib/pubid/iala/builder.rb

@@ -2,20 +2,20 @@
 
 module Pubid
   module Iala
-    # Builds an IALA identifier object from the Parslet parse tree.
+    # Builds an IALA identifier object from the artifact's bound map —
+    # the flat attribute hash the grammar's bindings block declares
+    # (typed at the engine, one key per capture).
     class Builder
       def build(parsed)
-        hash = parsed
+        return build_annex(parsed) if parsed[:annex_marker]
 
-        return build_annex(hash) if hash[:annex_marker]
-
-        type_letter = stringify(hash[:type_letter])&.upcase
+        type_letter = stringify(parsed[:type_letter])&.upcase
         klass = Iala.identifier_klass_for_type_letter(type_letter)
 
         attrs = {
-          number:   build_number(hash, klass),
-          edition:  stringify(hash.dig(:edition, :edition_value)),
-          language: stringify(hash.dig(:language_group, :language))&.upcase,
+          number: build_number(parsed, klass),
+          edition: stringify(parsed[:edition_value]),
+          language: stringify(parsed[:language])&.upcase,
         }.compact
 
         klass.new(**attrs)
@@ -27,31 +27,34 @@ module Pubid
 
       private
 
-      # Build the Annex wrapper from the parse tree. The base sub-tree
-      # (captured under :base) is recursively built via the same logic as
-      # a flat identifier, then wrapped.
+      # Build the Annex wrapper from the bound map. The base composite in
+      # the grammar stays unbound: its captures (type_letter, doc_number,
+      # …) are the only occurrence of each name on the annex path, so the
+      # harvest hoists them to the top level and this branch reads the
+      # same flat keys as the plain identifier.
       def build_annex(hash)
-        base_hash = hash[:base]
-        base_type = stringify(base_hash[:type_letter])&.upcase
+        base_type = stringify(hash[:type_letter])&.upcase
         base_klass = Iala.identifier_klass_for_type_letter(base_type)
-        base = base_klass.new(number: build_number(base_hash, base_klass))
+        base = base_klass.new(number: build_number(hash, base_klass))
 
         attrs = {
           base: base,
-          annex_form:      stringify(hash[:annex_marker]),
-          letter:          stringify(hash[:annex_letter]),
-          edition:         stringify(hash.dig(:edition, :edition_value)),
-          language:        stringify(hash.dig(:language_group, :language))&.upcase,
+          annex_form: stringify(hash[:annex_marker]),
+          letter: stringify(hash[:annex_letter]),
+          edition: stringify(hash[:edition_value]),
+          language: stringify(hash[:language])&.upcase,
         }.compact
 
         Identifiers::Annex.new(**attrs)
       end
 
-      # Compose the full number string from the leading doc_number plus any
-      # dotted continuation (GA01.13 → "01.13", L2.1.11 → "2.1.11") plus
-      # the optional dash-separated subpart (C0103-1 → "0103-1", L2.7.1-2
-      # → "2.7.1-2"). Padding is class-driven: the resolved identifier
-      # class declares its canonical IALA cover-page widths via
+      # Compose the full number string from the bound map's three number
+      # columns: the leading doc_number, the dotted continuation segments
+      # (doc_number_dots, each `{dotted_segment: "01"}`) and the dash
+      # subpart runs (subpart, each `{subpart_number: "1"}`). GA01.13 →
+      # "01.13", L2.1.11 → "2.1.11", C0103-1 → "0103-1", L2.7.1-2 →
+      # "2.7.1-2". Padding is class-driven: the resolved identifier class
+      # declares its canonical IALA cover-page widths via
       # `canonical_number_width` / `canonical_dotted_segment_width`, so a
       # new type declares its padding on its own class instead of editing
       # this builder's case statement.
@@ -61,34 +64,40 @@ module Pubid
 
         base = canonical_base(base, klass)
 
-        dots = hash[:doc_number_dots]
-        dots_str = dots.is_a?(Array) ? "" : canonical_dots(stringify(dots).to_s, klass)
+        dots = canonical_dots(
+          number_segments(hash[:doc_number_dots], :dotted_segment), klass
+        )
+        dots_str = dots.empty? ? "" : ".#{dots}"
+
+        subparts = number_segments(hash[:subpart], :subpart_number)
+        subpart_str = subparts.empty? ? "" : "-#{subparts.join('-')}"
 
-        subpart_str = hash[:subpart] ? "-#{subpart_to_s(hash[:subpart])}" : ""
-        subpart_str = "" if subpart_str == "-"
         "#{base}#{dots_str}#{subpart_str}"
       end
 
+      # The string values of a bound repetition column: doc_number_dots
+      # carries `{dotted_segment: …}` elements, subpart carries
+      # `{subpart_number: …}` elements.
+      def number_segments(column, key)
+        Array(column).filter_map do |element|
+          stringify(element[key]) if element.is_a?(Hash)
+        end
+      end
+
       def canonical_base(base, klass)
         width = klass&.canonical_number_width
         width ? base.rjust(width, "0") : base
       end
 
-      def canonical_dots(str, klass)
-        return "" if str.empty?
+      # Pad each dotted continuation segment to the class's canonical
+      # width; nil width preserves the segments verbatim (the L series).
+      def canonical_dots(segments, klass)
+        return "" if segments.empty?
 
         width = klass&.canonical_dotted_segment_width
-        return str unless width
-
-        str.split(".", -1).map { |seg| seg.empty? ? seg : seg.rjust(width, "0") }.join(".")
-      end
-
-      # The subpart capture may be an array of {subpart_number: "1"},
-      # {subpart_number: "9"}, … (repeated matches). Join with "-".
-      def subpart_to_s(subpart)
-        return stringify(subpart).to_s unless subpart.is_a?(Array)
+        return segments.join(".") unless width
 
-        subpart.filter_map { |h| h.is_a?(Hash) ? stringify(h[:subpart_number]) : nil }.join("-")
+        segments.map { |segment| segment.rjust(width, "0") }.join(".")
       end
 
       def stringify(value)

data/lib/pubid/iala/identifier.rb

@@ -33,7 +33,7 @@ module Pubid
         if FormatDetector.detect(identifier) == :urn
           UrnParser.parse(identifier)
         else
-          parsed = Pubid::Parg::Backend.parse(:iala, identifier)
+          parsed = Pubid::Parg::Model.bound(:iala, identifier)
           Builder.build(parsed)
         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,7 @@ module Pubid
 
         # Parse AIEE identifier string
         def self.parse(input)
-          parsed = Pubid::Parg::Backend.parse(:aiee, input,
+          parsed = Pubid::Parg::Model.bound(:aiee, input,
                                     entry: "aiee_identifier")
           Builder.new.build(parsed)
         end

data/lib/pubid/ieee/builder.rb

@@ -283,21 +283,90 @@ module Pubid
         # Parslet can return array of hashes - merge them
         parsed_hash = parsed.is_a?(Array) ? merge_parsed_array(parsed) : parsed
 
+        # The grammar binds the bare top-level draft clause as
+        # :draft_version_scalar (string) — the only cross-engine-stable
+        # scalar — and the composite draft rule as :draft_version_composite
+        # (raw). Surface the scalar under the top-level key the rest of the
+        # builder has always read, and the composite under the interior key
+        # the draft-element walks read.
+        if parsed_hash[:draft_version].nil? && parsed_hash[:draft_version_scalar]
+          parsed_hash[:draft_version] = parsed_hash.delete(:draft_version_scalar)
+        end
+        draft_elems = parsed_hash[:draft].is_a?(Array) ? parsed_hash[:draft] : [parsed_hash[:draft]]
+        draft_elems.each do |e|
+          next unless e.is_a?(Hash) && e[:draft_version].nil? && e[:draft_version_composite]
+
+          e[:draft_version] = e.delete(:draft_version_composite)
+        end
+        # The subpart run ("7.4-3-2" carries two) rides the raw
+        # part_subpart_year wrapper — the subparts[] array harvest emitted
+        # empty hashes for non-firing rep iterations on wasm
+        # (parsanol-ruby#399), so the run no longer binds top-level.
+        # Hoist the wrapper's part/year and deep-collect its interior
+        # subparts so every consumer — and every raw subtree built through
+        # here (the CSA dual's ieee_portion, the multi-numbered primary,
+        # the supplement bases) — sees the flat keys it has always read.
+        parsed_hash = unwrap_part_subpart_year(parsed_hash)
+
         # Grammar-captured dash dates (relaton's "/D-3-2017-07" and
         # "/R-x-2011-04" tails) land on the identifier's year/month exactly
         # like the number's own date clause. The revision-suffix form sits at
         # the top level; the draft tail nests under :draft — either as its
         # own element or wrapped in a draft_version hash.
+        # A revision element INSIDE the draft array is the draft rule's own
+        # split artifact (the version's trailing ".1" segment) — the spine
+        # captured the same value, and leaving it there makes the REV-date
+        # embed glue the draft date into the designator. A rev_inline
+        # capture never lands inside the draft array, so this only ever
+        # drops the artifact.
+        if parsed_hash[:draft].is_a?(Array) && parsed_hash[:revision]
+          artifact = parsed_hash[:draft].any? do |e|
+            e.is_a?(Hash) && e.key?(:revision) && e[:revision].to_s == parsed_hash[:revision].to_s
+          end
+          parsed_hash.delete(:revision) if artifact
+        end
+        # The edition-2 tree materializes a multi-segment draft version
+        # ("D2.1.1") as per-token nodes carrying no :draft_version key. The
+        # v1 tree degraded such a clause to a whole-clause LEAF string when
+        # no draft date follows (the designator survives through the
+        # Draft.parse inverse), and to a date-only hash when it does (the
+        # version is dropped, no draft built). Normalize to the v1 shape
+        # here — before the stage derivation and draft handling read it —
+        # so every consumer sees what v1 saw.
+        if parsed_hash[:draft].is_a?(Array)
+          draft_elems = parsed_hash[:draft].select { |e| e.is_a?(Hash) }
+          if !draft_elems.empty? && draft_elems.none? { |e| e.key?(:draft_version) }
+            has_date = draft_elems.any? { |e| e.key?(:draft_date_month) || e.key?(:draft_date_year) }
+            if has_date
+              date_elems = draft_elems.select do |e|
+                e.key?(:draft_date_month) || e.key?(:draft_date_year) || e.key?(:draft_date_day)
+              end
+              parsed_hash[:draft] = date_elems.inject({}, :merge)
+            else
+              parsed_hash[:draft] = draft_elems.flat_map { |e| e.values }.join
+            end
+          end
+        end
         drafts = parsed_hash[:draft].is_a?(Array) ? parsed_hash[:draft] : [parsed_hash[:draft]].compact
         drafts.each do |d|
           next unless d.is_a?(Hash) && d[:draft_version].is_a?(Hash)
           dv = d[:draft_version]
-          d[:dash_year] = dv[:dash_year] if dv[:dash_year]
-          d[:dash_month] = dv[:dash_month] if dv[:dash_month]
+          # The edition-2 grammar renames the nested draft-version dash
+          # captures (draft_version_dash_year/month) to keep them out of the
+          # flat bound map; the v1 tree spelling stays as the fallback.
+          d[:dash_year] = (dv[:draft_version_dash_year] || dv[:dash_year]) if
+            dv[:draft_version_dash_year] || dv[:dash_year]
+          d[:dash_month] = (dv[:draft_version_dash_month] || dv[:dash_month]) if
+            dv[:draft_version_dash_month] || dv[:dash_month]
           d.delete(:draft_version)
         end
         dash = parsed_hash[:dash_year] ? parsed_hash : nil
-        dash ||= drafts.find { |d| d.is_a?(Hash) && d[:dash_year] }
+        # The draft_date captures rename with the draft_date_ prefix on the
+        # edition-2 grammar (nested-only, kept off the identity keys); v1
+        # spelling stays as the fallback.
+        dash ||= drafts.find do |d|
+          d.is_a?(Hash) && (d[:draft_date_dash_year] || d[:dash_year])
+        end
         if dash.nil? && parsed_hash[:draft]
           # A numeric month trailing a draft is the draft's own date: it
           # embeds in the designator ("D09, 04 2011" -> "D09-2011-04")
@@ -323,25 +392,32 @@ module Pubid
         if dash
           joined = drafts.filter_map { |d| d.is_a?(Hash) ? d[:draft_version] : nil }
                          .map { |v| v.is_a?(Hash) ? v[:value] : v.to_s }.join
+          # dash is either the top-level spine (dash_year/dash_month) or the
+          # draft's own hash (draft_date_dash_year/month on the edition-2
+          # grammar, dash_year/month on v1) — read both spellings.
+          dash_y = dash[:dash_year] || dash[:draft_date_dash_year]
+          dash_m = dash[:dash_month] || dash[:draft_date_dash_month]
           bare_joint_draft = parsed_hash[:joint_publishers] &&
                              parsed_hash[:part].nil? &&
                              parsed_hash[:iso_stage].nil? &&
                              drafts.any? { |d| d.is_a?(Hash) && d[:draft_version] }
           dash_led = joined.start_with?("-")
           if bare_joint_draft && dash_led
-            parsed_hash[:part] = { value: dash[:dash_year] }
-          elsif dash[:dash_month] &&
+            parsed_hash[:part] = { value: dash_y }
+          elsif dash_m &&
                 (host = drafts.find { |d| d.is_a?(Hash) && d[:draft_version] })
             # The draft's own numeric date embeds in the designator
             # ("D2-2015-04") — the "D2, 04 2015" comma spelling
             # normalizes onto it (pubid ruling 2026-10-13).
             host[:draft_version] =
-              [joined, dash[:dash_year], dash[:dash_month]].compact.join("-")
+              [joined, dash_y, dash_m].compact.join("-")
             dash.delete(:dash_year)
             dash.delete(:dash_month)
-          elsif (dash[:dash_month] || dash_led) && parsed_hash[:year].nil?
-            parsed_hash[:year] = dash[:dash_year]
-            parsed_hash[:month] = dash[:dash_month]
+            dash.delete(:draft_date_dash_year)
+            dash.delete(:draft_date_dash_month)
+          elsif (dash_m || dash_led) && parsed_hash[:year].nil?
+            parsed_hash[:year] = dash_y
+            parsed_hash[:month] = dash_m
           else
             # Year-only tail embeds in the draft face ("D9-2006"), the model
             # the relaton-pinned renders use for corrupted update_codes
@@ -353,15 +429,17 @@ module Pubid
               # ("D9-2006", and with its month "D2-2015-04") — the
               # "D2, 04 2015" comma spelling normalizes onto it.
               host[:draft_version] =
-                [joined, dash[:dash_year], dash[:dash_month]].compact.join("-")
+                [joined, dash_y, dash_m].compact.join("-")
               dash.delete(:dash_year)
               dash.delete(:dash_month)
+              dash.delete(:draft_date_dash_year)
+              dash.delete(:draft_date_dash_month)
               # the hyphenated "/D-2-2007" spelling's year the spine
               # captured at top level is the draft's own — vacate it
-              parsed_hash.delete(:year) if parsed_hash[:year] == dash[:dash_year]
+              parsed_hash.delete(:year) if parsed_hash[:year] == dash_y
             else
-              parsed_hash[:year] = dash[:dash_year]
-              parsed_hash[:month] = dash[:dash_month]
+              parsed_hash[:year] = dash_y
+              parsed_hash[:month] = dash_m
             end
           end
         end
@@ -456,8 +534,11 @@ module Pubid
             # "IEEE P15026.2/D=FDIS-201008" (pubid#203 ruling). The
             # stage and date ride the designator; the ISO face is not
             # elected.
-            year = extract_value(fd[:year])
-            month = extract_value(fd[:month])
+            # fdraft's month/year rename with the fdraft_ prefix on the
+            # edition-2 grammar (nested-only); v1 spelling stays as the
+            # fallback.
+            year = extract_value(fd[:fdraft_year] || fd[:year])
+            month = extract_value(fd[:fdraft_month] || fd[:month])
             date = ""
             if year
               date = "-#{year}"
@@ -500,6 +581,11 @@ module Pubid
       def reconstruct_base_string(base_data)
         base_parts = []
 
+        # The part/subpart/year captures sit one level down, inside the
+        # raw part_subpart_year wrapper (parsanol-ruby#399) — hoist them
+        # before the flat reads below.
+        base_data = unwrap_part_subpart_year(base_data)
+
         # Extract publisher
         if base_data[:publishers]
           pub_data = base_data[:publishers]
@@ -536,11 +622,14 @@ module Pubid
           number_str += part_val if part_val
         end
 
-        # Add subpart if present
+        # Add subpart if present — the bound run arrives as subparts[]
+        # harvest hashes ({subpart: …}); v1's flat spelling stays as the
+        # fallback.
         if base_data[:subpart]
           subparts = base_data[:subpart]
           subparts = [subparts] unless subparts.is_a?(Array)
           subparts.each do |sp|
+            sp = sp[:subpart] if sp.is_a?(Hash) && sp.key?(:subpart)
             subpart_val = extract_value(sp)
             number_str += subpart_val if subpart_val
           end
@@ -681,7 +770,7 @@ module Pubid
       def build_interpretation_supplement(parsed_hash)
         # Reconstruct base identifier string from parsed components (same logic as corrigendum)
         base_parts = []
-        base_data = parsed_hash[:base]
+        base_data = unwrap_part_subpart_year(parsed_hash[:base])
 
         # Extract publisher
         if base_data[:publishers]
@@ -714,11 +803,14 @@ module Pubid
           number_str += part_val if part_val
         end
 
-        # Add subpart if present
+        # Add subpart if present — the bound run arrives as subparts[]
+        # harvest hashes ({subpart: …}); v1's flat spelling stays as the
+        # fallback.
         if base_data[:subpart]
           subparts = base_data[:subpart]
           subparts = [subparts] unless subparts.is_a?(Array)
           subparts.each do |sp|
+            sp = sp[:subpart] if sp.is_a?(Hash) && sp.key?(:subpart)
             subpart_val = extract_value(sp)
             number_str += subpart_val if subpart_val
           end
@@ -754,7 +846,7 @@ module Pubid
       def build_conformance_supplement(parsed_hash)
         # Reconstruct base identifier string from parsed components (same logic as corrigendum)
         base_parts = []
-        base_data = parsed_hash[:base]
+        base_data = unwrap_part_subpart_year(parsed_hash[:base])
 
         # Extract publisher
         if base_data[:publishers]
@@ -787,11 +879,14 @@ module Pubid
           number_str += part_val if part_val
         end
 
-        # Add subpart if present
+        # Add subpart if present — the bound run arrives as subparts[]
+        # harvest hashes ({subpart: …}); v1's flat spelling stays as the
+        # fallback.
         if base_data[:subpart]
           subparts = base_data[:subpart]
           subparts = [subparts] unless subparts.is_a?(Array)
           subparts.each do |sp|
+            sp = sp[:subpart] if sp.is_a?(Hash) && sp.key?(:subpart)
             subpart_val = extract_value(sp)
             number_str += subpart_val if subpart_val
           end
@@ -1320,9 +1415,12 @@ module Pubid
         # Extract SI type (SI or PSI)
         si_type = extract_value(parsed[:si_type])
 
-        # Extract publishers (should be "IEEE/ASTM")
-        if parsed[:publishers]
-          publishers_str = extract_value(parsed[:publishers])
+        # Extract publishers (should be "IEEE/ASTM") — the SI rule's bare
+        # publishers clause binds as publishers_scalar (string); the
+        # composite joint rows deliver :publishers (raw).
+        pub_src = parsed[:publishers] || parsed[:publishers_scalar]
+        if pub_src
+          publishers_str = extract_value(pub_src)
           # Split by slash to get individual publishers
           pubs = publishers_str.split("/")
           attributes[:publisher] = pubs.first
@@ -1334,6 +1432,10 @@ module Pubid
 
         # For PSI (draft), create proper Draft component object
         if si_type == "PSI"
+          # The bare top-level draft clause binds as :draft_version_scalar
+          # (string) — surface it under the key this builder reads.
+          parsed[:draft_version] = parsed.delete(:draft_version_scalar) if
+            parsed[:draft_version].nil? && parsed[:draft_version_scalar]
           if parsed[:draft_version]
             draft_version = extract_value(parsed[:draft_version])
             # Create Draft component (Lutaml::Model object)
@@ -1904,6 +2006,42 @@ module Pubid
         str_value.length.positive? ? str_value : nil
       end
 
+      # Deep-first collection of every :subpart node under a raw
+      # part_subpart_year wrapper (Hash or Array, any nesting).
+      def collect_subparts(node, out = [])
+        case node
+        when Hash
+          node.each do |key, value|
+            if key.to_sym == :subpart
+              out << value
+            else
+              collect_subparts(value, out)
+            end
+          end
+        when Array then node.each { |item| collect_subparts(item, out) }
+        end
+        out
+      end
+
+      # The part/subpart/year captures ride the raw part_subpart_year
+      # wrapper inside raw subtrees (parsanol-ruby#399: the subparts[]
+      # array harvest is not cross-engine stable, so the run does not
+      # bind top-level). Hoist the wrapper's part/year onto a copy of the
+      # subtree and surface the interior subpart run under :subpart, so
+      # the flat reads downstream see the shapes they always read.
+      def unwrap_part_subpart_year(node)
+        return node unless node.is_a?(Hash) && (run = node[:part_subpart_year])
+
+        nodes = run.is_a?(Array) ? run : [run]
+        flat = nodes.select { |item| item.is_a?(Hash) }.inject({}, :merge)
+        node = node.merge(flat.slice(:part, :year))
+        unless node[:subpart]
+          collected = collect_subparts(run)
+          node = node.merge(subpart: collected) unless collected.empty?
+        end
+        node
+      end
+
       # Extract optional attribute if present
       def extract_optional(parsed, attributes, key)
         value = extract_value(parsed[key])
@@ -2004,15 +2142,20 @@ module Pubid
           iso_stage ||= extract_value(draft_data[:draft_iso_stage]) if draft_data[:draft_iso_stage]
           iso_iteration = extract_value(draft_data[:draft_iso_iteration]) if draft_data[:draft_iso_iteration]
 
-          # Extract date information from draft data
-          month_slice = draft_data[:month]
+          # Extract date information from draft data. The edition-2 grammar
+          # renames draft_date's nested month/year/day captures with the
+          # draft_date_ prefix (kept off the identity keys); the v1
+          # spellings stay as the fallback.
+          month_slice = draft_data[:draft_date_month] || draft_data[:month]
           month = extract_value(month_slice) if month_slice
-          year = extract_value(draft_data[:year]) if draft_data[:year]
+          year = extract_value(draft_data[:draft_date_year] || draft_data[:year]) if
+            draft_data[:draft_date_year] || draft_data[:year]
           # The apostrophe-year catalogue convention ("P1484.20.1/D7,
           # May 07"): the 2-digit year expands with the <30 pivot so the
           # hash carries an unambiguous year.
           year = "#{year.to_i < 30 ? 20 : 19}#{year}" if year.to_s.match?(/\A\d{2}\z/)
-          day = extract_value(draft_data[:day]) if draft_data[:day]
+          day = extract_value(draft_data[:draft_date_day] || draft_data[:day]) if
+            draft_data[:draft_date_day] || draft_data[:day]
 
           # A REV-carrying draft embeds its print date into the designator
           # with the month canonicalized numeric (pubid ruling 2026-10-14):
@@ -2103,7 +2246,11 @@ module Pubid
       def handle_reaffirmed(parsed, attributes)
         if parsed[:reaffirmed].is_a?(Hash)
           reaf_data = parsed[:reaffirmed]
-          attributes[:reaffirmed] = extract_value(reaf_data[:year])
+          # The edition-2 grammar renames the nested year capture
+          # (reaffirmed_year) so the reaffirmation year cannot leak onto
+          # the identity year key; v1 spelling stays as the fallback.
+          attributes[:reaffirmed] =
+            extract_value(reaf_data[:reaffirmed_year] || reaf_data[:year])
         elsif parsed[:reaffirmed]
           attributes[:reaffirmed] = extract_value(parsed[:reaffirmed])
         end

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

@@ -23,13 +23,21 @@ module Pubid
         attribute :parts, :string, collection: true # Array of part strings
         attribute :original_separator, :string # Original separator (. or -) from parsing
 
+        # The separator BEFORE each part, when the source mixed them
+        # ("7.4-3-2" — dot after the number, dashes before the subparts).
+        # Runtime-only (a plain accessor, not a lutaml attribute): the
+        # serialized columns keep the single original_separator, and only
+        # a fresh parse knows the per-part spelling.
+        attr_accessor :original_separators
+
         def initialize(prefix: nil, number: nil, parts: nil,
-original_separator: nil)
+original_separator: nil, original_separators: nil)
           super()
           self.prefix = prefix
           self.number = number
           self.parts = parts || []
           self.original_separator = original_separator
+          self.original_separators = original_separators
         end
 
         # Parse code string into components
@@ -55,15 +63,45 @@ original_separator: nil)
           components = remainder.split(/[.-]/)
           number = components.shift
 
+          # The separators AS PRINTED, one per part boundary — a code may
+          # mix them ("7.4-3-2": dot after the number, dashes before the
+          # subparts), and to_s re-joins with these instead of the uniform
+          # original_separator when they were captured.
+          separators = remainder.scan(/[.-]/)
+          per_part = separators.length == components.length ? separators : nil
+
           new(
             prefix: prefix,
             number: number,
             parts: components.empty? ? nil : components,
             original_separator: separator,
+            original_separators: per_part,
           )
         end
 
+        # The printed face: keeps the separator each part was printed
+        # with ("7.4-3-2"), per Pubid::SubsetMatch. Spellings that differ
+        # only in part separators denote the same document, so faces that
+        # must be spelling-stable — the URN and the joint IEEE/ISO faces —
+        # render through #canonical_to_s instead.
         def to_s
+          render_code(per_part: true)
+        end
+
+        # The canonical face: one uniform separator across every part
+        # boundary (the first distinct one the source printed, the same
+        # face this class rendered before per-part separators were kept).
+        def canonical_to_s
+          render_code(per_part: false)
+        end
+
+        def render(context: nil)
+          to_s
+        end
+
+        private
+
+        def render_code(per_part:)
           result = ""
           result += prefix if prefix
           result += number if number # Guard against nil number (e.g., "ANSI X")
@@ -95,17 +133,18 @@ original_separator: nil)
               separator = "."
             end
 
-            parts.each do |part|
-              result += separator + part
+            parts.each_with_index do |part, idx|
+              # A fresh parse of mixed-separator codes ("7.4-3-2") carries
+              # the separator each part was printed with; the canonical
+              # face (and an unknown per-part spelling) falls back to the
+              # uniform original separator (the serialized shape).
+              sep = (per_part && original_separators&.at(idx)) || separator
+              result += sep + part
             end
           end
 
           result
         end
-
-        def render(context: nil)
-          to_s
-        end
       end
     end
   end

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

@@ -403,7 +403,10 @@ module Pubid
           return build_dual(result.parts) if result.dispatch == :dual_semicolon
         end
         parser_input = Parser.normalize_input(normalized)
-        parsed = Pubid::Parg::Backend.parse(:ieee, parser_input)
+        # The edition-2 artifact's bindings block produces the builder-ready
+        # hash at the engine (typed scalars + raw wrappers); the tree
+        # backend's normalization it replaces read the edition-1 shapes.
+        parsed = Pubid::Parg::Model.bound(:ieee, parser_input)
         builder = Builder.new(Identifier)
         # Pass the original input string to builder for context
         builder.original_input = input

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

@@ -164,7 +164,10 @@ module Pubid
           # P11073.10418", #216); a plain ISO/IEC number keeps the
           # printed separator ("IEC/IEEE FDIS 60079-30-2", "ISO/IEC
           # 8802-3").
-          code_str = code.to_s
+          # Canonical (uniform-separator) code: a joint document parses
+          # from both the dotted IEEE face and the dashed IEC face, and
+          # both spellings must render — and URN — identically.
+          code_str = code.canonical_to_s
           code_str = code_str.tr("-", ".") if code_str.start_with?("P")
           code_str += mark unless code_str.empty?
           parts << code_str if code_str && !code_str.empty?
@@ -213,8 +216,9 @@ module Pubid
           parts << draft_status if draft_status
 
           # Build code part — the P-state prints as spelled (P = project
-          # draft; no P = standard). Never added or stripped.
-          code_str = code.to_s
+          # draft; no P = standard). Never added or stripped. Canonical
+          # code for the same both-faces reason as the ISO face above.
+          code_str = code.canonical_to_s
 
           # Mark after the number, before the draft and the year
           code_str += mark unless code_str.empty?