pubid 2.0.20 → 2.0.21

data/lib/pubid/bipm/builder.rb

@@ -39,6 +39,8 @@ module Pubid
           build_si_brochure_section(data[:si_brochure_section])
         elsif data.key?(:si_brochure_ordinal_edition)
           build_si_brochure_ordinal_edition(data[:si_brochure_ordinal_edition])
+        elsif data.key?(:si_brochure_bare_edition)
+          build_si_brochure_bare_edition(data[:si_brochure_bare_edition])
         elsif data[:mep]
           build_mep(data[:mep])
         elsif data[:guide]
@@ -119,7 +121,7 @@ module Pubid
           number: node[:edition].to_s,
           edition: node[:edition].to_s,
           version: node[:version]&.to_s,
-          years: node[:years].to_s,
+          years: node[:years]&.to_s,
           language: Identifier.normalize_language(node[:language]),
         )
       end
@@ -153,6 +155,23 @@ module Pubid
         )
       end
 
+      # The unmerged si-brochure-id proposal spells the edition as a bare
+      # number ("SI Brochure 9 (2024) (F)"); the guide's canonical edition
+      # carries the trailing "e", so the bare number normalizes onto it the
+      # same way the corpus-cited ordinal spelling does. The proposal puts the
+      # year and the language in separate parentheses; they map onto the same
+      # attributes the canonical form prints, and an absent year stays nil (a
+      # partial reference, like "SI Brochure 9th edition" without a year).
+      def build_si_brochure_bare_edition(node)
+        edition = "#{node[:bare_edition]}e"
+        Identifiers::SiBrochure.new(
+          number: edition,
+          edition: edition,
+          years: node[:year]&.to_s,
+          language: Identifier.normalize_language(node[:language]),
+        )
+      end
+
       # The Appendix/Annex/Part tail is the full-content spelling of the SAME
       # document, so it stays out of the key.
       def build_mep(node)

data/lib/pubid/bipm/renderer.rb

@@ -57,6 +57,15 @@ module Pubid
       def render_committee_long(id)
         if id.language == "F"
           name = Identifier::TYPE_NAME_FR[id.type_code]
+          # The guide's body-prefixed French pattern ("Décision CIPM/111-10
+          # (2022)") is the canonical long face: the group qualifies the
+          # resource-specific id with a slash. A number-less document has no
+          # id to qualify, so it keeps the connective spelling the guide's
+          # general French pattern uses ("Statement de la CGPM (1889)").
+          if id.number
+            return "#{name} #{id.group}/#{id.number}#{year_segment(id)}"
+          end
+
           conn = Identifier.french_connective(id.group)
           "#{name}#{number_segment(id)} #{conn} #{id.group}#{year_segment(id)}"
         else
@@ -91,12 +100,15 @@ module Pubid
 
         # The version is optional (the guide's "SI Brochure 9e (2019, E)" form)
         # and the language code too (the language-independent form), so both
-        # segments are conditional.
+        # segments are conditional. The parens carry the year, the language or
+        # both, and stay off entirely when the reference names neither ("SI
+        # Brochure 9e", the bare-number alias without a year).
         phrase = id.language == "F" ? "sur le SI " : ""
         lang = id.language ? ", #{id.language}" : ""
+        tail = id.years ? "#{id.years}#{lang}" : id.language.to_s
         result = +"BIPM SI Brochure #{phrase}#{id.edition}"
         result << " #{id.version}" if id.version
-        result << " (#{id.years}#{lang})"
+        result << " (#{tail})" if id.years || id.language
         result
       end
 

data/lib/pubid/bipm/urn_generator.rb

@@ -3,12 +3,50 @@
 module Pubid
   module Bipm
     # Emits a URN carrying the canonical (language/form-neutral) document
-    # identity for each family:
-    #   committee:  urn:bipm:<group>:<type>:<number>:<year>   (empty number seg
-    #                                                          when number-less)
-    #   meeting:    urn:bipm:<group>:meeting:<number>:<year>
-    #   metrologia: urn:bipm:metrologia:<vol>[:<issue>[:<article>]]
-    #   brochure:   urn:bipm:si-brochure:<lang>:<edition>:<version>:<years>
+    # identity for each family, in the guide-of-record's official shapes
+    # (bipm-editor-guides, sources/bipm-references-en.adoc, "URN" clauses):
+    #
+    #   committee:  urn:bipm:v1:<group>:<type-word>:<identifier>[:<year>]
+    #   meeting:    urn:bipm:v1:<group>:meeting:<number>[:<year>]
+    #   metrologia: urn:bipm:v1:metrologia:<vol>[:<issue>[:<article>]]
+    #   brochure:   urn:bipm:v1:bipm:si-brochure:<edition>:[<version>]:<year>
+    #
+    # The guide's general pattern is
+    # `urn:bipm:{version}:{group}:{venue-type}:{venue-id}
+    #  :{type}:{identifier}:{date}` with the venue slots optional. The
+    # flavor holds no venue attribute — the venue qualification lives
+    # inside the document number itself ("110-17" is the 110th meeting's
+    # decision 17) — so the venue slots stay unfilled and one shape per
+    # family falls out:
+    #
+    #   * committee — the guide's `decision` example verbatim:
+    #     `urn:bipm:v1:cipm:decision:110-17:2021`. The type segment is the
+    #     English type name lowercased (resolution/recommendation/decision/
+    #     action/statement), not the REC/RES/DECN abbreviation the previous
+    #     face carried; the empty segment stays for the type-less bare MRA
+    #     form. The guide's second committee example
+    #     (`urn:bipm:v1:cipm:resolution:95-2006:1`) does not fit the stated
+    #     pattern — it puts a venue-id (meeting 95, year 2006) and the
+    #     outcome ordinal where the pattern's identifier/date slots sit
+    #     (its own git history edited it there from `95-2006:resolution:1`,
+    #     which DID fit). This flavor emits the pattern-conforming shape;
+    #     a venue-qualified number flows through the identifier slot
+    #     verbatim.
+    #   * meeting — the venue-type `meeting` plus the venue-id, as separate
+    #     segments per the guide's meeting-outcomes component list (its only
+    #     accepted venue-type value). The guide's proceedings example glues
+    #     them (`meeting-26`) and carries a proceedings type + publication
+    #     year this flavor does not model.
+    #   * metrologia — the guide defines no metrologia URN (its section is
+    #     empty), so only the mandatory `v1` convention applies; the series
+    #     shape is unchanged.
+    #   * brochure — the guide's pattern verbatim: the `bipm` group lead,
+    #     the edition without its `e` ("9e" → "9"), the version without its
+    #     `v` ("v3.01" → "3.01"), the language segment dropped (the guide's
+    #     URN is language-independent) and the year the latest the `years`
+    #     range names ("2019/2024" → "2024", the guide's "latest year of
+    #     publication at the version"). The version segment stays empty when
+    #     absent, per the guide's `urn:bipm:v1:bipm:si-brochure:9::2019`.
     class UrnGenerator < Pubid::UrnGenerator::Base
       def generate
         case identifier
@@ -23,18 +61,29 @@ module Pubid
 
       private
 
+      # The v1 version segment leads every family; the venue-type/venue-id
+      # slots of the guide's general pattern stay unfilled because the
+      # flavor carries no venue attribute (see the class comment).
       def committee
         id = identifier
-        # type_code is nil for the bare MRA form → empty type segment, mirroring
-        # the empty-number-segment convention for number-less documents.
-        parts = ["urn", "bipm", id.group.downcase,
-                 id.type_code.to_s.downcase, committee_number_segment(id)]
+        # type_code is nil for the bare MRA form → empty type segment,
+        # mirroring the empty-number-segment convention for number-less
+        # documents. The segment is the lowercase English type name the
+        # guide spells out ("decision"), never the REC/RES/DECN code.
+        parts = ["urn", "bipm", "v1", id.group.downcase,
+                 committee_type_segment(id), committee_number_segment(id)]
         # A partial (date-less) reference drops the trailing year segment; a
         # number-less-but-dated doc keeps its empty number segment.
         parts << id.year if id.year
         parts.join(":")
       end
 
+      def committee_type_segment(id)
+        return "" unless id.type_code
+
+        Identifier::TYPE_NAME_EN[id.type_code].downcase
+      end
+
       # The appendix/annex complement folds into the identifier segment as
       # "-a{appendix}[.{annex}]". A bare number is digits and dashes only, so
       # the letter-prefixed tail is unambiguous on the way back (UrnParser
@@ -50,21 +99,38 @@ module Pubid
 
       def meeting
         id = identifier
-        parts = ["urn", "bipm", id.group.downcase, "meeting", id.number.to_s]
+        parts = ["urn", "bipm", "v1", id.group.downcase, "meeting",
+                 id.number.to_s]
         parts << id.year if id.year
         parts.join(":")
       end
 
       def metrologia
-        parts = ["urn", "bipm", "metrologia", identifier.volume]
+        parts = ["urn", "bipm", "v1", "metrologia", identifier.volume]
         parts << identifier.issue if identifier.issue
         parts << identifier.article if identifier.article
         parts.join(":")
       end
 
       def si_brochure
-        ["urn", "bipm", "si-brochure", identifier.language.to_s.downcase,
-         identifier.edition, identifier.version, identifier.years].join(":")
+        id = identifier
+        ["urn", "bipm", "v1", "bipm", "si-brochure",
+         brochure_edition_segment(id), id.version.to_s.delete_prefix("v"),
+         brochure_year_segment(id)].join(":")
+      end
+
+      # The guide's edition-number carries no "e" ("Notice the absence of the
+      # letter e after the number"): "9e" emits "9". A variant (Appendix 3 /
+      # Concise / FAQ) or a bare section reference names no edition, so the
+      # segment is empty — the documented partial-reference bucket.
+      def brochure_edition_segment(id)
+        id.edition.to_s.delete_suffix("e")
+      end
+
+      # The guide's year is "the latest year of publication at the version":
+      # the "2019" of "2019", the "2024" of "2019/2024".
+      def brochure_year_segment(id)
+        id.years.to_s.split("/").last
       end
     end
   end

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,20 @@ 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`, `IEC/FDAM 60038` → `IEC FDAM 60038-60038` — 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.)
+
 ## 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/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/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