pubid 2.0.20 → 2.0.22

data/lib/pubid/bipm/urn_parser.rb

@@ -6,21 +6,52 @@ module Pubid
     # fields (rather than reconstructing a printed string) because the printed
     # forms carry surface detail — meeting ordinals, French wording — that the
     # canonical URN intentionally omits.
+    #
+    # Two URN generations parse. The canonical face leads with the guide's
+    # `v1` version segment (see UrnGenerator for the per-family shapes). The
+    # pre-adoption face this flavor emitted for years (`urn:bipm:cipm:res:
+    # 101-1:2012`, `urn:bipm:si-brochure:e:9e:v3.01:2019/2024`, …) stays
+    # parseable as a documented parse-in alias of the same identity: the
+    # landed relaton-data-bipm records and any consumer-stored URN keep
+    # resolving while the re-crawl lags. The EMITTER is the new shape; an
+    # alias never renders back as itself, it rebuilds the identifier whose
+    # `to_urn` is the v1 face.
     class UrnParser < Pubid::UrnParser::Base
       def parse_urn(urn)
         body = strip_namespace(urn)
         parts = body.split(":", -1)
 
+        if parts.first == "v1"
+          parse_canonical(parts.drop(1))
+        else
+          parse_legacy(parts)
+        end
+      end
+
+      private
+
+      # The v1 canonical shapes, with the version segment stripped. The
+      # brochure family differs structurally (group lead, no language
+      # segment, stripped e/v), so it dispatches before the group-leading
+      # committee/meeting shape.
+      def parse_canonical(parts)
         case parts.first
         when "metrologia" then build_metrologia(parts)
-        when "si-brochure" then build_si_brochure(parts)
-        else build_group_leading(parts)
+        when "bipm" then build_si_brochure_canonical(parts.drop(2))
+        else build_group_leading(parts, canonical_type: true)
         end
       end
 
-      private
+      # The legacy landed shapes (no v1 segment), kept as parse-in aliases.
+      def parse_legacy(parts)
+        case parts.first
+        when "metrologia" then build_metrologia(parts)
+        when "si-brochure" then build_si_brochure(parts)
+        else build_group_leading(parts, canonical_type: false)
+        end
+      end
 
-      def build_group_leading(parts)
+      def build_group_leading(parts, canonical_type:)
         group = parts[0].upcase
         if parts[1] == "meeting"
           Identifiers::Meeting.new(
@@ -30,13 +61,25 @@ module Pubid
           number, appendix, annex = split_appendix(parts[2])
           Identifiers::CommitteeDocument.new(
             group: group,
-            type_code: (parts[1].empty? ? nil : parts[1].upcase),
+            type_code: type_code_from_segment(parts[1],
+                                              canonical_type: canonical_type),
             number: (number.empty? ? nil : number), year: parts[3]&.to_i,
             appendix: appendix, annex: annex,
           )
         end
       end
 
+      # The legacy face carried the lowercase type abbreviation ("res"); the
+      # v1 face carries the lowercase English type name ("resolution"). Both
+      # resolve through TYPE_WORD_TO_CODE, so an empty segment (the bare MRA
+      # form) stays a nil type_code on either face.
+      def type_code_from_segment(segment, canonical_type:)
+        return nil if segment.nil? || segment.empty?
+
+        word = canonical_type ? segment.capitalize : segment.upcase
+        Identifier::TYPE_WORD_TO_CODE[word]
+      end
+
       # Inverse of UrnGenerator#committee_number_segment: splits the folded
       # "-a{appendix}[.{annex}]" tail back out of the identifier segment. A
       # bare number is digits and dashes only, so the letter-prefixed tail is
@@ -57,10 +100,31 @@ module Pubid
         )
       end
 
+      # Legacy brochure face: `si-brochure:<lang>:<edition>:<version>:<years>`.
       def build_si_brochure(parts)
         Identifiers::SiBrochure.new(
           number: presence(parts[2]), language: parts[1].to_s.upcase,
-          edition: parts[2], version: parts[3], years: parts[4]
+          edition: presence(parts[2]), version: presence(parts[3]),
+          years: presence(parts[4])
+        )
+      end
+
+      # Canonical brochure face:
+      # `bipm:si-brochure:<edition-number>:<version-number>:<year>` — the
+      # guide strips the "e" off the edition and the "v" off the version and
+      # drops the language segment, so they are restored here; the year
+      # segment stores back into `years` verbatim, which makes the emission
+      # idempotent ("2024" re-emits "2024"). The legacy face's language and
+      # multi-year segments are gone on this face: the guide's URN is
+      # language-independent and names the latest year only.
+      def build_si_brochure_canonical(parts)
+        edition = presence(parts[0])
+        edition = "#{edition}e" if edition
+        version = presence(parts[1])
+        version = "v#{version}" if version
+        Identifiers::SiBrochure.new(
+          number: edition, edition: edition, version: version,
+          years: presence(parts[2])
         )
       end
 

data/lib/pubid/ecma/CLAUDE.md

@@ -33,3 +33,15 @@ keeps `#matches?(other, ignore:)`.
   stripper (root `CLAUDE.md`, the `with_publisher:` bullet) leaves the string
   alone, and the `@with_publisher` ivar and the renderer branch that read it
   were deleted. XSF made the same change for `XEP 0001`.
+
+- **Human edition spellings are pre-parse aliases (pubid#698).** The
+  grammar reads exactly one edition face — the glued " ed<N>" — so
+  `Parser.normalize_input` (wired into `Identifier.parse`, the
+  ashrae/cie ingestion precedent) rewrites the human faces onto it before
+  the artifact sees them: the case-insensitive cover form
+  ("ECMA-262 Edition 5.1"), the dotted and spaced ed variants, and the
+  bare trailing edition ("ECMA 262 5.1"), which fires only behind an
+  already-present document number so the space-separator form ("ECMA 6")
+  keeps its number and a " vol<N>" is never rewritten. Every rule
+  rewrites INTO the canonical face, so a canonical string passes through
+  byte-identically and the index key stays "ECMA-262 ed5.1".

data/lib/pubid/ecma/identifier.rb

@@ -134,8 +134,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        identifier = ::Pubid.utf8_input(identifier)
-
+        identifier = Parser.normalize_input(::Pubid.utf8_input(identifier))
         parsed = Pubid::Parg::Model.bound(:ecma, identifier)
         Builder.build(parsed)
       end

data/lib/pubid/ecma/parser.rb

@@ -18,7 +18,56 @@ module Pubid
     # Each branch captures its number under a distinct key so the builder can
     # pick the identifier class without a separate type token. Numbers are kept
     # as strings to preserve any leading zeros.
+    #
+    # The grammar reads exactly one edition spelling — the glued " ed<N>" —
+    # while the SDO's own cover and the natural human spellings differ, so
+    # {Parser.normalize_input} rewrites those faces onto the glued token
+    # before the artifact sees them (pre-parse alias; the baked grammar is
+    # untouched). A canonical face passes through byte-identically.
     class Parser
+      # The human edition spellings that alias the glued " ed<N>" token
+      # (pubid#698), in rewrite order. Each rule rewrites into the exact
+      # canonical face, so the parse (and therefore the render, the URN and
+      # the index key) is the one " ed<N>" already produces.
+      #
+      #   ECMA-262 Edition 5.1   the document cover's own form
+      #   ECMA-262 ed. 5.1       dotted, spaced
+      #   ECMA-262 ed 5.1        spaced, undotted
+      #   ECMA-262 ed.5.1        dotted, unspaced
+      #   ECMA 262 5.1           bare trailing edition
+      #
+      # " ed5.1" (no separator) is the grammar's own face and is left alone;
+      # a " vol<N>" number is never rewritten — the bare-trailing rule fires
+      # only behind a document number's own digit, so "ECMA-269 ed3 vol2"
+      # and even the spaced "… vol 2" keep their volume.
+      EDITION_ALIASES = [
+        # "Edition <N>" starts mid-word, so the replacement carries no space
+        # of its own — the space before it is kept as-is.
+        [/\bedition[.\s]*(\d+(?:\.\d+)?)\b/i, 'ed\1'],
+        # "ed. <N>" / "ed <N>" / "ed.<N>": same mid-word shape. The glued
+        # "ed5.1" has no separator after "ed" and cannot match [.\s]+, so a
+        # canonical face passes through byte-identically.
+        [/\bed[.\s]+(\d+(?:\.\d+)?)\b/i, 'ed\1'],
+        # Bare trailing edition: fires only when a document number is already
+        # present (a digit directly before the space — "ECMA 262 5.1"), so the
+        # space-separator form itself ("ECMA 6") keeps its number: there the
+        # char before the space is "A", not a digit. The match consumes that
+        # one space and the replacement puts it back before the token. A
+        # glued "vol2" has no space, and a spaced "vol 2" has no digit before
+        # the space, so a volume number is never rewritten — the grammar's
+        # ed-then-vol order is untouched.
+        [/(\d) (\d+(?:\.\d+)?)\z/, '\1 ed\2'],
+      ].freeze
+
+      # Pre-parse ingestion normalization: map the human edition spellings
+      # onto the glued token the grammar reads. Every rule rewrites INTO a
+      # canonical face, so a string the grammar already accepts is returned
+      # byte-identically and only new accepts are added.
+      def self.normalize_input(string)
+        EDITION_ALIASES.reduce(string) do |acc, (pattern, replacement)|
+          acc.gsub(pattern, replacement)
+        end
+      end
     end
   end
 end

data/lib/pubid/iec/CLAUDE.md

@@ -27,16 +27,24 @@ These notes were part of the root `CLAUDE.md`. Read them before you change `lib/
 
 - **`number`/`part`/`subpart` are plain `:string`, `Iec::Components::Code` is deleted, and three of eleven `key_value` converters go with it.** The component was an empty box: over all **12,331** parseable pass fixtures the three were an `Iec::Components::Code` **9,975 / 5,422 / 2,416** times and **not one** populated `prefix`, `parts`, `part` or `subpart` inside it. The subclass existed solely for a `to_s` that prints `"#{prefix} #{value}"`; `Code.parse` was the only site that ever passed `prefix:` and it had **zero callers**, as did the `full_code` alias, and the class had zero references outside `identifier.rb` and its own file. So the subclass is deleted outright along with its `autoload`.
   **This was a live defect, not tidiness, and it is the reason to prefer retyping over coercing.** The parse path produced a Code while the constructor path left a String — a `:string` assigned to a Code-typed attribute stays a String — so `Identifiers::InternationalStandard.new(number: "60068", part: "2", subpart: "28", year: "2008")` was **not `==`** `Pubid::Iec.parse("IEC 60068-2-28:2008")`, and `#matches?` is `exclude(*ignore) == other.exclude(*ignore)`, so every match between a hand-built reference and a parsed one silently returned false. `to_s`, `to_urn` **and** `to_hash` all agreed on both sides, which is exactly why nothing caught it: a relaton index lookup just returned nothing, with no error. `spec/pubid/attribute_construction_spec.rb` had even pinned the String half (`"leaves a scalar number uncoerced (IEC)"`) and asserted `to_s` and `to_hash` on the two paths — but never `==`, so the spec that was closest to the bug documented it as intended behaviour. **The lesson generalises: a spec comparing two construction paths must assert `==`, not only that they render and serialize alike.**
-  **`with:` was doing two jobs, and only one of them was the Code.** `emit_code`/`build_code` unwrapped and rewrapped the component — identity functions once the attribute is a String — but the converters were *also* the mechanism by which `DelegatedFieldSuppression` no-opped the delegated fields of the four wrapper types. **Placement replaces the denylist**: `number`/`part`/`subpart` now map on **`Pubid::Iec::SingleIdentifier`**, the parent of `Identifiers::Base` and `SupplementIdentifier` — the only two classes that own a number — while `FragmentIdentifier`, `ConsolidatedIdentifier`, `VapIdentifier` and `SheetIdentifier` inherit from `Iec::Identifier` **directly** and are therefore excluded structurally, not by remembering to add a no-op. That distinction is not academic: the surviving denylist suppresses `year` but **not `month`/`day`/`undated`**, so `IEC CA 01:2025-10 CSV` still emits a top-level `"month" => "10"` duplicating the one inside `base` — a pre-existing leak, left alone here because removing a key from published rows is a wire change (hand-off `iec-wrapper-month-day-leak`).
+  **`with:` was doing two jobs, and only one of them was the Code.** `emit_code`/`build_code` unwrapped and rewrapped the component — identity functions once the attribute is a String — but the converters were *also* the mechanism by which `DelegatedFieldSuppression` no-opped the delegated fields of the four wrapper types. **Placement replaces the denylist**: `number`/`part`/`subpart` now map on **`Pubid::Iec::SingleIdentifier`**, the parent of `Identifiers::Base` and `SupplementIdentifier` — the only two classes that own a number — while `FragmentIdentifier`, `ConsolidatedIdentifier`, `VapIdentifier` and `SheetIdentifier` inherit from `Iec::Identifier` **directly** and are therefore excluded structurally, not by remembering to add a no-op. The date keys followed later — see the date-keys bullet below.
   **Two more converters were pure boilerplate.** `all_parts` is a Boolean attribute with `default: false` that `::Pubid::Identifier#to_hash` already drops, so it takes the plain GB spelling `map "all_parts", to: :all_parts, render_default: false`. `stage_iteration` holds a `Components::Iteration` — one `:string` field, `number`, whose `to_s`/`render` return it — so it joins the shared `FLAT_SCALAR_COMPONENTS`/`FLAT_SCALAR_FIELDS` tables on `::Pubid::Identifier` and takes a plain map too. **The blast radius of that shared change is exactly ISO and IEC**, the only two flavors that map the key, and both already emitted the bare scalar through their own converters — ISO keeps its converter, which the inflation guard defers to by design. Net: **12 converter methods and 2 helpers deleted**. The five groups that keep `with:` all earn it — `year`/`month`/`day` and `undated` split one `date` attribute across four keys, `publisher`/`copublishers` map a `Components::Publisher` to its `body` and omit the IEC default, and `stage` maps `typed_stage` to its code with class-scoped resolution on load. **The rule this leaves behind: a converter is for a custom class or for splitting one attribute across several keys; a primitive needs a plain map.**
   **The shared splitter gained a hook rather than a special case.** `Builder::Base#parse_number_with_part(value, code_class:)` is used by ISO and IEC only; `code_class:` is now optional and the three constructions route through `wrap_number_component`, which returns the raw scalar when `code_class` is nil. ISO still passes `Pubid::Iso::Components::Code` and is untouched. This is the extension point the remaining tranches reuse.
   **Verified by replaying a captured baseline, not by the suite alone.** Over all **12,331** IEC pass-fixture ids, `to_s`, `to_urn`, `to_mr_string`, `root.number`, the identifier class, the deep-key-sorted `to_hash`, the `from_hash(to_hash) == to_hash` flag and the `from_hash(to_hash) == id` flag are **byte-identical, 0 diffs in every field**. The verbatim `to_hash` differs for 9,950 rows and for **one reason only** — `number`/`part`/`subpart` moved to the end of the key order, because lutaml *appends* a subclass's `key_value` maps to the parent's; removing those three keys leaves the two key sequences identical for every row, and `Hash#==` ignores order, so **0 rows differ in any other way**. Over all **7,573** ISO pass-fixture ids every field including the verbatim hash is byte-identical, so neither shared-file change moved ISO. Against the published `relaton-data-iec` `index-v2.yaml` (**32,847** rows) `from_hash(row).to_hash == row` holds for 32,845 and `parse(from_hash(row).to_s) == from_hash(row)` for all 32,847, **both before and after** — the 2 misses are the pre-existing rows storing the old nested `edition: {number: …}` form. **No index migration follows**, and that is measured rather than assumed. Locked by `spec/pubid/iec/number_string_spec.rb` (structural tripwire over the whole class tree, the constructed-vs-parsed `==`, the wrapper hashes, and the absence of the deleted constant) and by IEC's entry in `spec/pubid/number_string_retype_spec.rb`.
   **Known residue, deliberately unchanged:** after the map moved, `Pubid::Iec::Identifier.from_hash({"number" => "60038"})` — a hand-written hash with **no `_type`**, on the bare base class — silently drops the key instead of building an `Identifier` that holds it. That object is already degenerate (`to_s` on it raises `NoMethodError` for `publisher_portion`) and nothing in this repo or in `relaton-iec` constructs one. (hand-off: iec-number-string.)
 
+- **The date keys map on `SingleIdentifier` too — the wrapper `month`/`day`/`undated` leak is closed.** The denylist that `number` escaped had drifted exactly as its failure mode predicts: `DelegatedFieldSuppression` (and `FragmentIdentifier`'s inline copy) no-opped `year_to_kv` but not `month_to_kv`/`day_to_kv`/`undated_to_kv`, so every wrapper whose wrapped document had a month or was undated emitted the key twice — `IEC CA 01:2025-10 CSV` → top-level `"month" => "10"` beside the one in `base`, and the pubid URN carried it as `…:vi:month-10:…`. Vap, Consolidated, Sheet and Fragment all leaked; `AllParts` did not. The fix is the same placement, not three more no-ops: the four date `map` lines and their eight converters moved from `Iec::Identifier` to `SingleIdentifier`, and `year_to_kv` left both denylists. It was safe because **no wrapper wants a top-level date key from `date`** — `SheetIdentifier`'s own `year` attribute serializes as `sheet_year`, a different key. The denylist now holds only `publisher`/`copublishers`/`stage`, which the parent block still needs. **Measured, not assumed:** replaying all 12,331 IEC pass fixtures against a `main` baseline, `to_s`, `to_urn`, `to_mr_string`, `to_pubid_urn`, `root.number`, the class, `to_hash` by `==` and the `from_hash(to_hash) == id` flag are identical for every id — the corpus holds **0** wrapper ids with a month, day or undated date, so no fixture moved. The verbatim key order moves for 7,761 dated rows (the date keys now come after the parent block, as `number` did); `Hash#==` ignores order and the pubid URN codec uses schema order. A local copy of `relaton-data-iec/index-v2.yaml` (32,634 rows) holds 0 `month`/`day`/`undated` keys at any depth, so **no index regeneration follows**; a legacy row that still carries a leaked key deserializes to the same identifier (the stray key is ignored). Locked by `spec/pubid/iec/wrapper_date_keys_spec.rb` (structural tripwire per wrapper class, month/day/undated cases across the four wrappers, both round trips, the legacy row). (hand-off: iec-wrapper-month-day-leak.)
+
   **Two parent-slot gaps recorded by the cross-flavor `base` survey** (`lib/pubid/bsi/CLAUDE.md` has the measured version). `Identifiers::TestReportForm#cispr_identifier` is a polymorphic `Identifier` parent slot with no `#root` override, so `root` returns the form itself — ratified as DELIBERATE by #687 (a TRF is a form about the CISPR document, not a wrapper of it; see the unserialized-identity bullet). And `Identifiers::ConsolidatedIdentifier#base_document` returns `identifiers&.first` **without** the recursive `&.base_document` that its BSI, CSA and CEN counterparts use — a one-level peel where the others peel fully, so a consolidated edition of a supplement does not reduce to the bare standard. Neither is chased here; both are pinned by nothing, which is why they are written down.
 
   **Stage codes — the SSOT and what is settled.** The authoritative source for IEC stage abbreviations is committed in this repo: **`data/iec/stage-codes.md`** — the 52-row IEC/ISO stage-code correspondence table transcribed from IEC's official *IEC/ISO Harmonized APIs* documents (v0.0.8 2023-06, api-portal.iec.ch; v0.0.7 2021-05, iec-apiportal.apigee.io — the successors that replace the IEC Data Feeds), the legacy Data-Feeds field examples, and the IS-lifecycle ladder from `StageCodes_IS_v2.pdf` (2023-06). `www.iec.ch` itself is fully WAF-gated to non-browsers and the Wayback Machine holds no snapshots of its PDFs, so the extract — not the unreachable original — is the reference. **`Pubid::Iec.locate_stage` reads `TYPED_STAGES` only** (`lib/pubid/iec.rb`); `PROJECT_STAGES` (AFDIS, TCDV, PRVC…) are not queryable through it. Every one of metanorma-iec's 55 `STAGE_CODES` — the list quoted in pubid#237 — resolves, locked by `spec/pubid/iec/typed_stages_spec.rb` in the issue's own order; aliases are always **appended, never prepended**, so `abbr.first` (what renders) is unchanged. Notable rulings from that pass: **ADIS** is the legacy Data-Feeds spelling of AFDIS ("Approved for FDIS circulation", ISO_LEVEL 40.99) and is an alias on `cdv` (the typed stage claiming 40.99); **CDISH/CDPAS** are the 50.20 rows of the DISH/DPAS deliverables, not "committee draft ISH/PAS" (30.xx); **Reconciliation items recorded in the extract, deliberately not applied:** DELPUB sits at 99.60 there while the `is` ladder does not claim 99.60; CAN carries two codes (30.98 IS/TR/TS, 50.98 PAS/ISH/COR); the rows CDISH-table-siblings DECDISH/MERGED/SPLIT/PCC/PRVN/DEL/RPUB/TPUB and the per-deliverable translation/preparation families are not registered as typed-stage abbreviations.
 
+- **A standalone supplement is `==` its `from_hash(to_hash)` round trip — the cause was the synthetic base's stage, not the ivar swap.** A supplement written without its base (`IEC/FDAM 60038-1`, `IEC/DCOR 60038-1`, `IEC/DISH 60038-1`) gets a bare `Pubid::Iec::SingleIdentifier` base from `SupplementIdentifier#ensure_base`; `to_s`, `to_urn`, `to_hash` and `#hash` agreed on both paths, but `==` was false, so `#matches?` failed silently. **The hand-off blamed the swapped `@number`/`@part` ivars; that was wrong.** `EqualityIgnored#==` compares through `public_send`, so the reader overrides hid the swap from it. The real difference was `base.typed_stage`: `ensure_base` set an IS/undated `TypedStage` with no `code`, which `stage_to_kv` cannot serialize, so `from_hash` rebuilt the base with none. **Diagnose an `==` failure by diffing the attributes through their readers, recursively, before trusting a hypothesis about ivars.** The stage write is deleted (the JCGM "delete the write" shape); the one visible change is `root.to_s` of the synthetic base on the parse path (`IEC IS60038` → `IEC60038`, the value `from_hash` already gave). The ivar swap was cleaned up too, because it was a hazard: `ensure_base` now moves the supplement number from `@part` into `@number`, so the stored layout is what `from_hash` rebuilds, and the `#number`/`#part` overrides, `@supplement_number`, `@synthetic_base` and `mark_synthetic_standalone!` are gone. `synthetic_base?` reads `base.instance_of?(SingleIdentifier)`, so it also survives `#exclude`, which copies `base` into a new object (on `main` the copy lost the flag and rendered in attached form, `IEC IS60038/FDAM1`). **The move must not depend on which reader runs first**, and a first version got that wrong: it called `ensure_base` only in the slash-form branch of `Builder#build`, but the canonical spelling `IEC FDAM 60038-1` (what `to_s` prints) reaches a different grammar branch, so a fresh parse kept the grammar layout until something read `base` — `.number` answered `60038`, `to_mr_string` gave `iec.60038_amd.60038`, and `#exclude` (which copies through the readers) copied the unmoved numbers onto a base synthesised afterwards, rendering `IEC FDAM 60038-60038`. So `#number`/`#part` keep a thin override that only TRIGGERS the move (`settle_standalone_layout`: `ensure_base` when there is a `part` and no base) and then return the stored value, and `Iec::Identifier.parse` calls `ensure_base` on a top-level supplement so a fresh parse already stores the moved layout. Supplements without a part (consolidation members, `IEC/AMD 1:2017`) are untouched by either. Two renderings outside the fixture corpus move, both repairs: `exclude(:date)` of a standalone supplement keeps the standalone form, and `IEC FDAM 60038-1 (all parts)` renders as itself instead of `IEC IS60038/FDAM1 (all parts)`. One hazard is left, unreachable from the grammar: reading `part` on a hand-built supplement BEFORE its base is assigned synthesises a base and moves the number, so a later `base =` renders the moved number. **A second hand-off claim was also wrong: an equal `#hash` for two unequal objects is legal** (the rule is `a == b ⇒ a.hash == b.hash`); `compute_hash` does not read `base`, which is a collision, not a defect. Measured: all 12,331 pass-fixture ids are byte-identical in `to_s`, `to_urn`, `to_mr_string`, `root.number`, `to_hash` and class; all 32,949 `relaton-data-iec` `index-v2.yaml` rows keep `from_hash(row).to_hash == row` and `parse(from_hash(row).to_s) == from_hash(row)`, and none has a `pubid:iec:single-identifier` base, so **no index migration follows**. Locked by `spec/pubid/iec/standalone_supplement_round_trip_spec.rb` and by the six standalone fixtures now in `full/iec-pubid.txt`, which the whole-corpus `==` sweep in `spec/pubid/iec/root_number_spec.rb` covers. **Residue, deliberately unchanged:** the self-base form renders its number twice — `IEC/AMD 1:2017` → `IEC Amd 1-1:2017` — because `render_supplement_standalone` prints `base.number` and then the supplement's own number, which are the same value there. (hand-off: iec-standalone-supplement-ivar-swap.) **CORRECTED 2026-11-12 (owner ruling, reverses this bullet's identity):** the part-to-number move this bullet introduced is the DEFECT the legacy-decode bullet below removes. `IEC/FDAM 60038-1` is not "base 60038 with FDAM 1": the whole `60038-1` is the base designation. The equality machinery this bullet built (the stored layout `from_hash` rebuilds, the reader-triggered settle, `synthetic_base?` reading the class) is kept and holds on the corrected identity.
+
+- **The legacy prefix faces decode onto the modern identity (owner ruling 2026-11-12; evidence: `data/iec/legacy-notation.md`; reverses #693's resolution).** The old notation prints the stage token BEFORE the base designation — the JTC1 ballot faces `IEC/FDAM 60038-1`, `ISO/IEC PDAM 12207`, `ISO/IEC PDAM 2 10646:2012`, `ISO/IEC FPDAM 9075/1`, `ISO/IEC FDAM 1 14496-12:2004`, and the IEC draft faces `IEC/DCOR 60038-1`, `IEC/DISH 60038-1`, `IEC CDISH 60050-191`. #693's model had resolved those by STEALING the designation's part for the supplement (`ensure_base` moved `@part` into `@number`), so the old face and the modern on-base face (`IEC 60038-1/FDAM 1`) disagreed on the same document's identity. The decode now: **the designation moves WHOLE onto the base** (number, part, subpart, and the date — old notation prints the base's year, and a draft supplement carries no publication date of its own), **the supplement's number defaults to 1** (the no-number rule: an unnumbered DAM/PDAM/FDAM/FPDAM/DCOR/DISH means Amendment/Corrigendum/Interpretation-Sheet 1), and **the base is a concrete `InternationalStandard`**, not the synthetic `SingleIdentifier` — that concreteness is what makes the legacy face hash-match (and equal) the modern parse: `parse("IEC/DCOR 60038-1") == parse("IEC 60038-1/DCOR 1")`. The render is the modern on-base slash face (`IEC 60038-1/FDAM1`), so the legacy face is not a spelling facet — it is decoded, IHO-style.
+  **Two grammar halves.** The DAM-family prefix faces (`DAM`/`PDAM`/`FDAM`/`FPDAM`, spelled literally in the rule so the typed_stages table stays put for them) raised on main; the new `legacy_supplement` rule in `pubid-grammar` captures `legacy_stage`, the optional `legacy_supplement_number` (N before the base), and the base designation — including the old slash-part spelling (`FPDAM 9075/1` = base 9075, part 1; captured as `legacy_base_number` + `legacy_base_part`, and ordered BEFORE the dash-part alternative because `number_with_part` also matches a bare "9075", which would have left the "/1" dangling). The rule sits ahead of `standalone_supplement` in the ordered choice so both the slash and space faces reach it, and its date rides with the designation. PDAM/FPDAM joined the `iec_typed_stages` table and `Amendment::TYPED_STAGES` (stage codes mirror ISO's entries: PDAM at the CD level, FPDAM at the FDIS level; the LEAD harmonized codes are the circulation slots 30.20/50.20 — ISO's 30.00/50.00 are CDAM's and FDAM's (type, leading code) URN keys). The non-DAM draft faces (DCOR, FDCOR, CDISH, DISH, and any typed standalone with a designation-shaped token) already parsed; they are corrected by `ensure_base`, so the two paths converge on one decode. **The discriminator between a legacy face and a true standalone is the PART:** a designation token (`60038-1`, `9075/1`) moves whole onto the base; a bare ordinal (`IEC/AMD 1:2017`) is the supplement's own number and keeps the synthetic self-base (`IEC Amd 1-1:2017`, unchanged). Under the JTC1 reading a bare number after a DAM-family token is a base designation (`IEC FDAM 60038` → `IEC 60038/FDAM1`), not a self-base mangle — that residue from the #693 bullet is gone.
+  **Measured by the replay gate, not the suite alone:** over all 26,838 full-fixture inputs, `to_s`/`to_urn`/`to_mr_string`/`to_hash`/class/`root.number` are byte-identical to the `main` baseline EXCEPT exactly the 6 #693-era standalone rows (both faces of FDAM/DCOR/DISH `60038-1`), which re-resolve to the corrected identities; 0 inputs stopped parsing; the prefix faces go raise→parse (12,491 full entries → 12,359 pass, fail steady at 132). #693's equality invariant (`parse == from_hash(to_hash)`) holds on every corrected identity. Locked by `spec/pubid/iec/standalone_supplement_round_trip_spec.rb` (rewritten: legacy faces decode and equal their modern parses, the self-base standalone keeps its form), `stage_separator_spec.rb`, `amendment_spec.rb`, `corrigendum_spec.rb`, `interpretation_sheet_spec.rb`, and the pass fixtures re-pinned by `validation:classify`. **Remaining gaps, deliberately open:** the dotted on-base `/Amd.1` spelling still raises in the IEC flavor (ISO accepts it), and the stamped prefix faces (`ISO/IEC FPDAM 10373-6/Amd 9:2001`, `ISO/IEC PDAM 9541-1/Amd.4`, `ISO/IEC FDAM 19776-2:2005/Am1:2006`, `ISO/IEC PDAM TR 9573-11/Amd.1`) stay raising — their on-base amendment stamps need the dotted/ISO stamp spellings the IEC flavor does not carry (gap 4 of the draft); the ISO-side agent owns that study.
+
 ## pubid-scheme URN (issue #670; gaps closed by #687)
 
 `lib/pubid/iec/pubid_urn_schema.rb` completes the partial schema the IEEE

data/lib/pubid/iec/builder.rb

@@ -57,6 +57,53 @@ module Pubid
       def build(parsed_hash)
         all_parts = parsed_hash.delete(:all_parts)
 
+        # Legacy DAM-family prefix face (IEC/FDAM 60038-1, ISO/IEC PDAM 2
+        # 10646:2012, ISO/IEC FPDAM 9075/1): the JTC1 ballot spelling puts
+        # the stage token before the base designation. Decode onto the
+        # modern identity (owner ruling 2026-11-12, with data/iec/
+        # legacy-notation.md): the designation is the BASE's, kept whole —
+        # the old slash-part spelling "9075/1" is base 9075 part 1 — and
+        # the supplement's number is the captured N, defaulting to 1 (the
+        # no-number rule: unnumbered DAM/PDAM/FDAM/FPDAM means Amendment 1).
+        # The date rides with the designation (old notation prints the
+        # base's year); a draft supplement carries none of its own. The
+        # base builds through the ordinary single-document path, so it is
+        # the same InternationalStandard the modern on-base parse holds and
+        # `parse(legacy) == parse(modern)`.
+        if parsed_hash[:legacy_stage]
+          supp = build_supplement(
+            type_with_stage: parsed_hash[:legacy_stage],
+            number_with_part: parsed_hash[:legacy_supplement_number] || "1",
+          )
+          base_hash = {}
+          {
+            publisher: :publisher,
+            legacy_base_number_with_part: :number_with_part,
+            date: :date,
+            undated_marker: :undated_marker,
+            edition: :edition,
+            languages: :languages,
+          }.each do |source, target|
+            base_hash[target] = parsed_hash[source] if parsed_hash[source]
+          end
+          # The grammar binds the legacy face's copublisher as a top-level
+          # scalar (legacy_copublisher) — the wasm binder scatters array
+          # bindings over the sibling list when a bare copublisher node
+          # rides a flat shape — so the builder attaches it here, in the
+          # same shape the parse path used to carry.
+          if parsed_hash[:legacy_copublisher]
+            base_hash[:copublishers] = [{ copublisher: parsed_hash[:legacy_copublisher] }]
+          end
+          # The slash-part designation ("9075/1") captured number and part
+          # separately; they go on straight as the plain strings the retyped
+          # attributes are, not through cast (which has no :part type).
+          base = build(base_hash)
+          base.number = parsed_hash[:legacy_base_number].to_s if parsed_hash[:legacy_base_number]
+          base.part = parsed_hash[:legacy_base_part].to_s if parsed_hash[:legacy_base_part]
+          return apply_fragment_notation(wrap_with_supplement(base, supp),
+                                         parsed_hash)
+        end
+
         # Second supplement layer (/AMD1:2018/COR1:2019): build the
         # first-supplement form, then wrap the second supplement around
         # it.

data/lib/pubid/iec/identifier.rb

@@ -10,15 +10,15 @@ module Pubid
     # Iso::BundledIdentifier.) Fragment keeps its own stage/edition, so it
     # suppresses a subset inline instead of including this.
     #
-    # number/part/subpart are NOT here, and deliberately so: their maps live on
-    # SingleIdentifier, which the four wrappers do not inherit from, so the
-    # exclusion is structural rather than a denylist that can drift. Only a
-    # converter can be no-opped this way, so a key that needs `with:` for
-    # another reason — year, publisher, copublishers, stage — still lists here.
-    # (`month`/`day`/`undated` are missing from that list and leak a duplicated
-    # top-level key on a wrapper; pre-existing, see lib/pubid/iec/CLAUDE.md.)
+    # number/part/subpart and the date keys (year/month/day/undated) are NOT
+    # here, and deliberately so: their maps live on SingleIdentifier, which
+    # the wrappers do not inherit from, so the exclusion is structural rather
+    # than a denylist that can drift. (The denylist did drift: it once listed
+    # `year` but not `month`/`day`/`undated`, and those three leaked a
+    # duplicated top-level key on every wrapper.) Only publisher,
+    # copublishers and stage stay here, because those maps are still wanted
+    # on the parent block.
     module DelegatedFieldSuppression
-      def year_to_kv(_model, _doc); end
       def publisher_to_kv(_model, _doc); end
       def copublishers_to_kv(_model, _doc); end
       def stage_to_kv(_model, _doc); end
@@ -165,7 +165,7 @@ module Pubid
       key_value do
         map "_type", to: :_type, polymorphic_map: IEC_TYPE_MAP
         # number/part/subpart are NOT mapped here — they live on
-        # SingleIdentifier, the seam that excludes the four delegating wrappers.
+        # SingleIdentifier, the seam that excludes the delegating wrappers.
         # See the comment on that block.
         #
         # stage_iteration is a degenerate Components::Iteration (one :string
@@ -173,13 +173,9 @@ module Pubid
         # ::Pubid::Identifier flattens it to a bare scalar and inflates it back.
         # A plain map is enough; no converter.
         map "stage_iteration", to: :stage_iteration, render_default: false
-        # date serialized flat as year/month/day, nils omitted.
-        map "year", with: { to: :year_to_kv, from: :year_from_kv }
-        map "month", with: { to: :month_to_kv, from: :month_from_kv }
-        map "day", with: { to: :day_to_kv, from: :day_from_kv }
-        # IEC undated reference (e.g. IEC 60050:--). The `false` default is
-        # omitted; only the meaningful `true` round-trips via to_hash.
-        map "undated", with: { to: :undated_to_kv, from: :undated_from_kv }
+        # year/month/day/undated are NOT mapped here either — they live on
+        # SingleIdentifier for the same reason as number/part/subpart: a
+        # wrapper delegates `date` to what it wraps.
         map "edition", to: :edition, render_default: false
         map "languages", to: :languages, render_default: false
         # publisher emitted only when the primary isn't the IEC default;
@@ -195,59 +191,6 @@ module Pubid
         # already drops, so a plain map suffices (the GB spelling).
       end
 
-      # --- date serialized flat as year/month/day ---
-      def year_to_kv(model, doc)
-        y = model.date&.year
-        return if y.nil? || y.to_s.empty?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("year", y.to_s))
-      end
-
-      def year_from_kv(model, value)
-        return if value.nil? || value.to_s.empty?
-
-        (model.date ||= ::Pubid::Components::Date.new).year = value.to_s
-      end
-
-      def month_to_kv(model, doc)
-        m = model.date&.month
-        return if m.nil? || m.to_s.empty?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("month", m.to_s))
-      end
-
-      def month_from_kv(model, value)
-        return if value.nil? || value.to_s.empty?
-
-        (model.date ||= ::Pubid::Components::Date.new).month = value.to_s
-      end
-
-      def day_to_kv(model, doc)
-        d = model.date&.day
-        return if d.nil? || d.to_s.empty?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("day", d.to_s))
-      end
-
-      def day_from_kv(model, value)
-        return if value.nil? || value.to_s.empty?
-
-        (model.date ||= ::Pubid::Components::Date.new).day = value.to_s
-      end
-
-      # --- date undated flag (IEC undated reference, e.g. IEC 60050:--) ---
-      # The `false` default is omitted; only the meaningful `true` round-trips
-      # via to_hash / from_hash.
-      def undated_to_kv(model, doc)
-        return unless model.date&.undated?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("undated", true))
-      end
-
-      def undated_from_kv(model, value)
-        (model.date ||= ::Pubid::Components::Date.new).undated = value.to_s == "true"
-      end
-
       # --- publisher: primary only when non-default; copublishers as a list ---
       def publisher_to_kv(model, doc)
         pub = model.publisher&.body
@@ -326,7 +269,13 @@ module Pubid
         # Apply legacy update_codes normalization first, before any other preprocessing
         normalized = Core::UpdateCodes.apply(string, :iec)
         parsed = Pubid::Parg::Model.bound(:iec, Pubid::Iec::Parser.normalize_input(normalized))
-        Pubid::Iec::Builder.new.build(parsed)
+        id = Pubid::Iec::Builder.new.build(parsed)
+        # A standalone supplement stores its numbers in the layout from_hash
+        # rebuilds only after #ensure_base runs; run it here, so a fresh
+        # parse holds that layout before any reader runs
+        # (SupplementIdentifier#number).
+        id.ensure_base if id.is_a?(SupplementIdentifier)
+        id
       end
 
       # from_hash is the shared polymorphic dispatch on Pubid::Identifier.

data/lib/pubid/iec/identifiers/amendment.rb

@@ -54,6 +54,25 @@ module Pubid
             name: "Committee Draft Amendment",
             harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
           ),
+          # The JTC1 ladder's pre-DAM ballot face (zero IEC-only record usage
+          # — the DAM family rides on joint work only; see
+          # data/iec/legacy-notation.md). Stage codes mirror the ISO flavor's
+          # entry for the same letter: PDAM sits at the CD level (30.xx).
+          # The LEAD harmonized code is the circulation slot (30.20
+          # "circulated as CD"), not ISO's 30.00 — the URN writes
+          # stage-{harmonized_stages.first} and parses it back by
+          # (type, leading code), which CDAM (30.00) already claims; see
+          # spec/pubid/iec/pnw_stage_spec.rb.
+          Pubid::Components::TypedStage.new(
+            code: :pdam,
+            stage_code: :cd,
+            type_code: :amd,
+            abbr: ["PDAM"],
+            short_abbr: nil,
+            long_abbr: nil,
+            name: "Proposed Draft Amendment",
+            harmonized_stages: %w[30.20 30.00 30.60 30.92 30.93 30.98 30.99],
+          ),
           Pubid::Components::TypedStage.new(
             code: :damd,
             stage_code: :damd,
@@ -74,6 +93,21 @@ module Pubid
             name: "Final Draft Amendment",
             harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
           ),
+          # The JTC1 ladder's pre-FDAM ballot face (same provenance as PDAM
+          # above): FPDAM mirrors the ISO flavor's entry, at the FDIS level
+          # (50.xx). Its LEAD harmonized code is the circulation slot
+          # (50.20), not ISO's 50.00, which FDAM already claims as its
+          # (type, leading code) URN key.
+          Pubid::Components::TypedStage.new(
+            code: :fpdam,
+            stage_code: :fdamd,
+            type_code: :amd,
+            abbr: ["FPDAM"],
+            short_abbr: nil,
+            long_abbr: nil,
+            name: "Final Proposed Draft Amendment",
+            harmonized_stages: %w[50.20 50.00 50.60 50.92 50.98 50.99],
+          ),
           Pubid::Components::TypedStage.new(
             code: :pubamd,
             stage_code: :published,

data/lib/pubid/iec/identifiers/corrigendum.rb

@@ -44,7 +44,12 @@ module Pubid
             code: :cdcor,
             stage_code: :cd,
             type_code: :cor,
-            abbr: ["CDCor"],
+            # "CDCOR" is the all-caps spelling the attached-supplement
+            # renderer emits (abbr.first.upcase) when a legacy prefix face
+            # decodes onto a CDCor draft ("IEC/CDCor 60038-1" renders
+            # "IEC 60038-1/CDCOR1"); appended as an alias so the canonical
+            # render re-parses. abbr.first stays "CDCor" (spelling-only).
+            abbr: ["CDCor", "CDCOR"],
             short_abbr: "CDCor",
             long_abbr: "CD Cor",
             name: "Committee Draft Corrigendum",

data/lib/pubid/iec/identifiers/fragment_identifier.rb

@@ -25,9 +25,9 @@ module Pubid
           map "fragment_number", to: :fragment_number, render_default: false
         end
 
-        # number/part/subpart need no no-op here: their maps live on
-        # SingleIdentifier, which this class does not inherit from.
-        def year_to_kv(_model, _doc); end
+        # number/part/subpart and year/month/day/undated need no no-op here:
+        # their maps live on SingleIdentifier, which this class does not
+        # inherit from.
         def publisher_to_kv(_model, _doc); end
         def copublishers_to_kv(_model, _doc); end
 

data/lib/pubid/iec/single_identifier.rb

@@ -22,15 +22,80 @@ module Pubid
       # their own (Identifiers::Base and SupplementIdentifier).
       #
       # That is a structural exclusion, not a denylist of no-op converters that
-      # a later key can be forgotten from — which is how `month`/`day` came to
-      # leak (see DelegatedFieldSuppression).
+      # a later key can be forgotten from. The date keys live here for the
+      # same reason: the wrappers delegate `date` too, and when the date maps
+      # sat on Iec::Identifier the denylist no-opped `year` but not
+      # `month`/`day`/`undated`, so `IEC CA 01:2025-10 CSV` emitted a second,
+      # top-level "month" beside the one inside "base".
       #
-      # The values are plain strings, so no converter is needed: lutaml writes
-      # the scalar, and ::Pubid::Identifier#to_hash drops a nil.
+      # number/part/subpart are plain strings, so no converter is needed:
+      # lutaml writes the scalar, and ::Pubid::Identifier#to_hash drops a nil.
+      # The date keys keep converters, because they split one `date`
+      # attribute across four keys.
       key_value do
         map "number", to: :number
         map "part", to: :part
         map "subpart", to: :subpart
+        # date serialized flat as year/month/day, nils omitted.
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "month", with: { to: :month_to_kv, from: :month_from_kv }
+        map "day", with: { to: :day_to_kv, from: :day_from_kv }
+        # IEC undated reference (e.g. IEC 60050:--). The `false` default is
+        # omitted; only the meaningful `true` round-trips via to_hash.
+        map "undated", with: { to: :undated_to_kv, from: :undated_from_kv }
+      end
+
+      # --- date serialized flat as year/month/day ---
+      def year_to_kv(model, doc)
+        y = model.date&.year
+        return if y.nil? || y.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("year", y.to_s))
+      end
+
+      def year_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
+
+        (model.date ||= ::Pubid::Components::Date.new).year = value.to_s
+      end
+
+      def month_to_kv(model, doc)
+        m = model.date&.month
+        return if m.nil? || m.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("month", m.to_s))
+      end
+
+      def month_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
+
+        (model.date ||= ::Pubid::Components::Date.new).month = value.to_s
+      end
+
+      def day_to_kv(model, doc)
+        d = model.date&.day
+        return if d.nil? || d.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("day", d.to_s))
+      end
+
+      def day_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
+
+        (model.date ||= ::Pubid::Components::Date.new).day = value.to_s
+      end
+
+      # --- date undated flag (IEC undated reference, e.g. IEC 60050:--) ---
+      # The `false` default is omitted; only the meaningful `true` round-trips
+      # via to_hash / from_hash.
+      def undated_to_kv(model, doc)
+        return unless model.date&.undated?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("undated", true))
+      end
+
+      def undated_from_kv(model, value)
+        (model.date ||= ::Pubid::Components::Date.new).undated = value.to_s == "true"
       end
 
       # Generate URN for this identifier