pubid 2.0.19 → 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/identifier.rb

@@ -957,9 +957,10 @@ module Pubid
     # The shared table names the components a printed identifier usually
     # carries — publisher, type, number, part, year. A flavor that keeps its
     # identity somewhere else answers with its own names appended: IEC's
-    # working documents are `technical_committee`/`wd_number`/`wd_stage`, and
-    # CSA's electrical code prints `cec_part`/`no_number` rather than the
-    # `number` it stores. Without this they carried no annotatable token at all.
+    # working documents are `technical_committee`/`wd_stage` (their document
+    # number IS `number`, issue #687), and CSA's electrical code prints
+    # `cec_part`/`no_number` rather than the `number` it stores. Without this
+    # they carried no annotatable token at all.
     #
     # Appending rather than replacing keeps whatever the shared table does
     # find; a token whose value is not in the string is skipped anyway.

data/lib/pubid/iec/CLAUDE.md

@@ -4,7 +4,12 @@ IEC typed stages, `from_hash` equality, and the `number` retype that deleted `Ie
 
 These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/iec/` or `spec/pubid/iec/`. The root file keeps the cross-flavor contract that every flavor obeys.
 
-- **IEC `from_hash(to_hash) == parse` — two `from_hash` defaults that diverged from the parse path**: `==` was false for **every** IEC identifier, while `to_s`, `to_urn` and `to_hash` were all correct — so the relaton index gate (`from_hash(to_hash) == to_hash`) passed and a lookup (parsed reference vs `from_hash`-ed row) silently returned nothing. Two independent causes, one family. **(1) `original_abbr`** — the JCGM defect verbatim, with a **second** injector: `Identifier.published_typed_stage` (the attribute default) **and** `#stage_from_kv` both `dup`ped the registry entry and set `original_abbr = canonical_abbreviation`, where the parse path (`Builder#locate_typed_stage`, the `:type_with_stage` cast) leaves it nil. Both writes are deleted; the `dup` stays (`TYPED_STAGES` is frozen, its elements are not). **The hand-off warned this fix was rendering-sensitive because IEC reads the field at `iec/builder.rb:161-163` (long-vs-short `Amd 1` vs `AMD1`). It is not: that read is UNREACHABLE.** The block is gated on `identifier.class.attributes.key?(:rendering_style)`, and **no IEC class declares a `rendering_style` attribute** — verified by force-loading all 26 IEC identifier classes and inspecting `.attributes`. The whole block (builder.rb 155–200) is dead, so the read is doubly dead: never executed, and reading a field already nil on the parse path. The long spelling is already collapsed on `main` (`…/Amd 1:2017` renders back `…/AMD1:2017`). The block is **kept with an explicit UNREACHABLE comment** rather than deleted, so the next reader does not mistake it for a live consumer again. **The general lesson: before copying the JCGM delete to another flavor, check not just whether the field is read but whether the READ IS REACHABLE — a gated block whose gate is never true is not a consumer.** **(2) `Amendment`/`Corrigendum` redeclared `attribute :type`** with `default: -> { self.class.type[:key] }`. The redeclaration shadowed the derived reader `Iec::Identifier#type` (`typed_stage&.to_type`) on those two classes only; `type` is not serialized, so on `from_hash` the default assigned the **Symbol** `:amd`/`:cor` where the parse path assigns a `Components::Type`, and lutaml does not cast it. Both declarations are deleted so the two classes inherit the derived reader like every other IEC type; the class method `self.type` is untouched and still used. This is the AMCA lesson in another guise — **a default (or converter) that yields a different runtime shape from the parse path is a sign the attribute should not be there at all**. It also repairs a **parse-path** bug, not just the round trip: `Builder#wrap_with_consolidated` builds its supplement directly and never calls `assign_attributes`, so a consolidated amendment member (`IEC 60050-300:2001+AMD1:2005 CSV`) returned the bare Symbol `:amd` from `.type` on `main` even when parsed — pinned by a spec. **Latent, deliberately not changed:** `Builder#locate_typed_stage` (the parse-path lookup) hands out the shared frozen-array element **without** a `dup`, unlike the two from_hash paths; harmless today because nothing mutates a `TypedStage` in place, but it is the same "frozen array, unfrozen elements" hazard. Verified: `to_s`, `to_urn` and `to_hash` **byte-identical** across all 12,303 inputs in `spec/fixtures/iec/identifiers/pass/`, so nothing serialized moves and **no index migration follows**; `==` rises from 0 to **9,914 of 12,302**. **Verified against the published `relaton-data-iec` dataset too, which is the measurement that matters**: over all **32,817 `index-v2.yaml` rows**, the consumer shape `parse(row.to_s) == from_hash(row)` goes from **0 to 32,817** (and `matches?(ignore: [:year])` with it), while `from_hash(h).to_hash == h` holds for all 32,817 **both before and after** — so the published index is already valid and **needs no regeneration**. Over the 32,855 primary docidentifiers in `data/*.yaml`, 32,813 parse (the 42 failures are pre-existing title-bearing forms like `IEC Technology Report Cyber security:2019`, unchanged by this) and for all 32,813 `to_s`, `to_urn` and `root.number` are identical before and after, with **0 empty index keys**. The fixture corpus is the stricter test only because it contains WorkingDocument/PNW/TRF forms that the crawler does not publish. Locked by `spec/pubid/iec/typed_stage_equality_spec.rb` and by deleting the `"Pubid::Iec"` entry from `PENDING_EQUALITY`. **The 2,388 that remain have a THIRD, unrelated cause and are deliberately out of scope**: `WorkingDocument` (`technical_committee`/`wd_number`/`wd_stage`/`wd_language`, 2,318 ids — `to_hash` is `{"_type"=>"pubid:iec:working-document"}` and **`root.number` is nil**, so every WD row keys the empty string), the PNW `wp_stage`/`wp_type` pair (32) and `TestReportForm#cispr_identifier` (38) are **never serialized at all**. Mapping them ADDS keys to `to_hash` and forces a `relaton-data-iec` re-crawl, which is a separate decision — and a low-value one today, since the published index contains **zero** `working-document` and **zero** `test-report-form` rows. (hand-off: iec-typed-stage-original-abbr; follow-up hand-off: iec-unserialized-identity-attributes.)
+- **IEC `from_hash(to_hash) == parse` — two `from_hash` defaults that diverged from the parse path**: `==` was false for **every** IEC identifier, while `to_s`, `to_urn` and `to_hash` were all correct — so the relaton index gate (`from_hash(to_hash) == to_hash`) passed and a lookup (parsed reference vs `from_hash`-ed row) silently returned nothing. Two independent causes, one family. **(1) `original_abbr`** — the JCGM defect verbatim, with a **second** injector: `Identifier.published_typed_stage` (the attribute default) **and** `#stage_from_kv` both `dup`ped the registry entry and set `original_abbr = canonical_abbreviation`, where the parse path (`Builder#locate_typed_stage`, the `:type_with_stage` cast) leaves it nil. Both writes are deleted; the `dup` stays (`TYPED_STAGES` is frozen, its elements are not). **The hand-off warned this fix was rendering-sensitive because IEC reads the field at `iec/builder.rb:161-163` (long-vs-short `Amd 1` vs `AMD1`). It is not: that read is UNREACHABLE.** The block is gated on `identifier.class.attributes.key?(:rendering_style)`, and **no IEC class declares a `rendering_style` attribute** — verified by force-loading all 26 IEC identifier classes and inspecting `.attributes`. The whole block (builder.rb 155–200) is dead, so the read is doubly dead: never executed, and reading a field already nil on the parse path. The long spelling is already collapsed on `main` (`…/Amd 1:2017` renders back `…/AMD1:2017`). The block is **kept with an explicit UNREACHABLE comment** rather than deleted, so the next reader does not mistake it for a live consumer again. **The general lesson: before copying the JCGM delete to another flavor, check not just whether the field is read but whether the READ IS REACHABLE — a gated block whose gate is never true is not a consumer.** **(2) `Amendment`/`Corrigendum` redeclared `attribute :type`** with `default: -> { self.class.type[:key] }`. The redeclaration shadowed the derived reader `Iec::Identifier#type` (`typed_stage&.to_type`) on those two classes only; `type` is not serialized, so on `from_hash` the default assigned the **Symbol** `:amd`/`:cor` where the parse path assigns a `Components::Type`, and lutaml does not cast it. Both declarations are deleted so the two classes inherit the derived reader like every other IEC type; the class method `self.type` is untouched and still used. This is the AMCA lesson in another guise — **a default (or converter) that yields a different runtime shape from the parse path is a sign the attribute should not be there at all**. It also repairs a **parse-path** bug, not just the round trip: `Builder#wrap_with_consolidated` builds its supplement directly and never calls `assign_attributes`, so a consolidated amendment member (`IEC 60050-300:2001+AMD1:2005 CSV`) returned the bare Symbol `:amd` from `.type` on `main` even when parsed — pinned by a spec. **Latent, deliberately not changed:** `Builder#locate_typed_stage` (the parse-path lookup) hands out the shared frozen-array element **without** a `dup`, unlike the two from_hash paths; harmless today because nothing mutates a `TypedStage` in place, but it is the same "frozen array, unfrozen elements" hazard. Verified: `to_s`, `to_urn` and `to_hash` **byte-identical** across all 12,303 inputs in `spec/fixtures/iec/identifiers/pass/`, so nothing serialized moves and **no index migration follows**; `==` rises from 0 to **9,914 of 12,302**. **Verified against the published `relaton-data-iec` dataset too, which is the measurement that matters**: over all **32,817 `index-v2.yaml` rows**, the consumer shape `parse(row.to_s) == from_hash(row)` goes from **0 to 32,817** (and `matches?(ignore: [:year])` with it), while `from_hash(h).to_hash == h` holds for all 32,817 **both before and after** — so the published index is already valid and **needs no regeneration**. Over the 32,855 primary docidentifiers in `data/*.yaml`, 32,813 parse (the 42 failures are pre-existing title-bearing forms like `IEC Technology Report Cyber security:2019`, unchanged by this) and for all 32,813 `to_s`, `to_urn` and `root.number` are identical before and after, with **0 empty index keys**. The fixture corpus is the stricter test only because it contains WorkingDocument/PNW/TRF forms that the crawler does not publish. Locked by `spec/pubid/iec/typed_stage_equality_spec.rb` and by deleting the `"Pubid::Iec"` entry from `PENDING_EQUALITY`. **The 2,388 that remained had a THIRD, unrelated cause — fixed by #687, see the unserialized-identity bullet below**: `WorkingDocument` (`technical_committee`/`wd_number`/`wd_stage`/`wd_language`, 2,318 ids — `to_hash` was `{"_type"=>"pubid:iec:working-document"}` and **`root.number` was nil**, so every WD row keyed the empty string), the PNW `wp_stage`/`wp_type` pair (32) and `TestReportForm#cispr_identifier` (38) were **never serialized at all**. (hand-off: iec-typed-stage-original-abbr; follow-up hand-off: iec-unserialized-identity-attributes — landed as #687.)
+
+- **The unserialized-identity attributes are serialized (issue #687) — `wd_number` moved into the inherited `number`, five plain `key_value` maps and one nested one added, `wp_type` stripped at the construction site.** Three families kept their identity in attributes no `key_value` map covered, so `to_s` was right while `to_hash` was not: 2,388 of the 12,331 pass fixtures were not `==` after `from_hash(to_hash)`, all 2,318 working documents shared one hash and the type-only URN `urn:pubid:iec:wd`, `root.number` keyed the empty string, and the 38 CISPR-bearing TRFs hashed to publisher+year alone. **(1) `wd_number` is the inherited `number`** — the "prefer the inherited attribute over a parallel one" rule: the attribute is deleted and `Builder#cast` routes the parsed `:wd_number` onto `number`, so `root.number`, the index key and `to_hash` all read it; `technical_committee`/`wd_language`/`wd_stage`/`wp_stage`/`wp_type` take plain maps (primitives need no converters). **The two forms of the class key `number` differently, and that asymmetry is kept, not reconciled.** The #687 open-question-1 ruling ("`number` holds `wd_number`, the committee is a separate column — the ISO/IEEE bucket-by-document-number semantics") says to follow the existing code, and the existing code keys the work-programme form by committee: `PNW 1-1597` has carried number `1` (the TC) and part `1597` (the item) since before #360. So the wd form keys by document number (`1/2457/FDIS` → `2457`) and the wp form by committee (`root.number` = `1`); the committee column (`technical_committee`, serialized now) disambiguates.
+  **(2) `wp_type` carried a trailing space** (`"PWI TR 100-36"` captures `"TR "`); the renderer stripped it at print time, so the stored value differed from what rendered. `Builder#cast` strips it now (an all-space value drops to nil) and the renderer's strip is gone with it — `to_s` is byte-identical. **(3) `TestReportForm#cispr_identifier` maps as a nested identifier** with the converter shape of `VapIdentifier#base_to_kv`/`#base_from_kv` — `to_hash` embeds the nested polymorphic hash, `from_hash` dispatches back through the type map. **`#root` of a TRF stays the form** (#687 open-question-2 ruling): a TRF is a form ABOUT the CISPR document, not a wrapper of it, so those 38 ids key the empty string BY DECISION — the serialized `cispr_identifier` is the identity, not a re-rooted number.
+  **The pubid-scheme URN gained six atoms** — `tc-`/`wdlang-`/`wdstage-`/`wpstage-`/`wptype-` and `cispr-` (kind `:id`), after `vap-` and before `lang-`, so landed URNs do not move — and a working document URNs per document (`urn:pubid:iec:wd:2457:tc-1:wdstage-FDIS`). **One measured surface moved beyond `to_hash` and the pubid URN: the official `urn:iec:std:` URN.** The 2,318 wd-form ids emitted NO official URN on main (`to_urn` was nil — the generator refuses a document with no number); with `number` populated they emit `urn:iec:std:iec:2457::::`, the same generator rule the 32 wp-form rows already followed on main (`PNW 1-1597 ED1` → `urn:iec:std:iec:1-1597::stage-10.20:ed-1:`). No id that had an official URN changed (0 of the other 9,988), and no published `relaton-data-iec` row is touched (the index holds zero `working-document`/`test-report-form` rows) — the movement is 2,318 gains in the direction of more identity, the #360 precedent.
+  **Replay-verified against a main baseline, not just the suite.** Over all 12,331 pass-fixture inputs (12,306 parseable; the 25 parse failures pre-existing): `to_s` byte-identical for all 12,306; `to_urn` differs for exactly the 2,318 formerly URN-less rows above; `to_mr_string` differs for exactly the same 2,318 rows, each from the degenerate publisher-only `iec` (which every working document keyed, the shared-key defect verbatim) to `iec.<number>`; `to_hash` ADDS keys — never removes one, never changes a value — for exactly the 2,388 family rows and nothing outside them; `==` after the round trip rises 9,918 → 12,306; all 12,306 `to_pubid_urn` strings parse back to the same hash. Locked by `spec/pubid/iec/root_number_spec.rb` (the six references, the whole-corpus `==`/root-number sweeps, both rulings) and the per-document URN examples in `spec/pubid/iec/pubid_urn_spec.rb`. (hand-off landed: iec-unserialized-identity-attributes.)
 
 - **PNW is a stage of its own (10.20), the stage separator is a space, and the URN is built from components — issue #360 items 1, 2 and 4.** The three are one change, because on `main` the URN was produced by a regex scraped over `identifier.to_s`, so the stage fix and the separator fix both moved it. Reference behaviour was taken from the installed `pubid-iec 1.15.21`, **except for the URN, where 1.x is the wrong oracle** — see below.
   **(1) PNW.** `identifiers/international_standard.rb` listed `PNW` inside the `code: :pwi` stage (harmonized `00.*`), so `IEC PNW 1000-1:2023 ED2` rendered back as `IEC/PWI 1000-1:2023 ED2`. IEC's portal and `pubid-iec-1.15.21/stages.yaml` both give `PNW: ["10.20"]`. PNW now has its own `code: :pnw` TypedStage with `harmonized_stages: ["10.20"]`, and **`10.20` was removed from `:np`** so a lookup by harmonized code is unambiguous — the URN now performs exactly that lookup. `Identifiers::WorkingDocument#stage` built a bare `Components::Stage` from a hand-written `{"PWI"=>"pwi","PNW"=>"pnw"}` map, giving a stage with no harmonized code and a `"pnw"` stage code that existed nowhere else; it resolves through `Pubid::Iec.locate_stage` instead. **The grammar needed no change for the reported form**: `working_programme_with_publisher` required a literal `/` after the publisher, so `IEC PNW 1000-1:2023` already fell through to `type_with_stage`. That rule was **deleted** (it had zero corpus inputs), and `render_working_document` no longer prefixes the publisher: a work-programme registration renders bare (`PNW 65-915 ED1`), because its number is TC-scoped (`86B-15`, `SyCCOMM-1`) rather than an IEC document number, and prefixing `IEC ` would break idempotence — `IEC PNW 65-915 ED1` re-parses as an International Standard. That alone repaired 32 fixture entries.
@@ -16,31 +21,35 @@ These notes were part of the root `CLAUDE.md`. Read them before you change `lib/
 
 - **`edition` serializes flat, and the date does not need to** (pubid#360 item 3): IEC's edition emitted a one-key hash, `edition: {number: "2"}`, for a value that is only ever a scalar. `lib/pubid/iec/builder.rb` has a **single** edition construction site and it writes `Edition.new(number: value&.to_s)` and nothing else, so the component is degenerate by construction — confirmed over all **12,331** parseable IEC fixtures, where 607 carry an edition and `number` is the only field ever populated (`year` and `original_text`: zero). It now emits `edition: "2"`, and `from_hash` reads both that and the stored nested form, so no published `relaton-data-iec` row stops deserializing. The mapping at `lib/pubid/iec/identifier.rb` stays a plain `map "edition", to: :edition`; the flattening is the shared rule on `::Pubid::Identifier`, not an IEC converter. **The date half needed no work at all** — IEC already serializes it flat as top-level `year`/`month`/`day`/`undated` through its own converters, so no `date` key ever reaches the shared flattener. **That is not a coincidence worth ignoring: IEC is the flavor that proves the flat rule has to be per identifier rather than per flavor.** Of its 9,730 dated identifiers, 9,728 carry a year alone, but **10 carry a month** (`IEC CA 01:2025-10`, `IECEE 02:2025-06(en)`, `IECEE AD-001:2024-06(en)`) and **2 are undated** (`IEC 60050:--`, `IEC 60050:—`). A flavor-wide "IEC dates are year-only" switch would have thrown those twelve away silently. `spec/pubid/flat_scalar_serialization_spec.rb` asserts both directions on IEC for exactly this reason.
 
-- **`WorkingDocument` is the one IEC type that still renders plain under `annotated: true`.** The cross-flavor annotator (`Renderers::Annotator`, see the root `CLAUDE.md`) wraps the identifier's own component values where they appear in the rendered string; a WorkingDocument's identity lives in `technical_committee` / `wd_number` / `wd_stage` / `wd_language`, none of which is one of those components. This is the same unserialized-identity gap already recorded above (`to_hash` is `{"_type"=>"pubid:iec:working-document"}` and `root.number` is nil), seen from the rendering side. Nothing raises — the flag is accepted and simply finds no token — so it is a missing span, not a failure. Fixing it means mapping those attributes, which forces a `relaton-data-iec` re-crawl, and remains the separate decision it already was. (hand-off: iec-unserialized-identity-attributes.)
+- **`WorkingDocument` annotates, and since #687 it serializes too.** The cross-flavor annotator (`Renderers::Annotator`, see the root `CLAUDE.md`) wraps the identifier's own component values where they appear in the rendered string; a WorkingDocument's identity lives in `technical_committee` / `number` / `wd_stage` / `wd_language`, so `annotation_tokens` names them explicitly (the wd form's document number IS the inherited `number` since #687 — it used to sit in the unserialized `wd_number`). The rendered annotated form is byte-identical before and after #687 (`<span class="docnumber">1</span>/<span class="docnumber">2457</span>/<span class="stage">FDIS</span>` both sides) — the gap #687 closed was the serialization one recorded above, not the rendering one. (hand-off: iec-unserialized-identity-attributes — landed.)
 
 - **The attribute path takes a plain scalar for language and copublisher — the residue of issue #360 item 3.** Items 1, 2 and 4 gave `IEC PNW 1000-1:2023 ED2` the right stage, separator and URN, and the constructor contract gave it `edition: 2` and `year: 2023`. The URN the issue asked for also carries a language, and that half still failed: `languages: ["en"]` stored raw Strings, so `to_s` raised `wrong number of arguments` at `lib/pubid/iec/single_identifier.rb:59` (`lang.to_s(lang_single:)`) and `to_urn` raised `undefined method 'code'` at `lib/pubid/iec/urn_generator.rb:190`. `copublishers: ["ISO"]` raised the same way on `body`. Both are now coerced by the shared `DEGENERATE_COMPONENT_FIELDS` rule on `::Pubid::Identifier` (see the root `CLAUDE.md`), not by an IEC converter — and IEC is the flavor that proves the wrap has to key on the component **class**, because its copublisher is the subclass `Pubid::Iec::Components::Publisher`, which an attribute-name or exact-class table would miss. So `Identifiers::InternationalStandard.new(number: "1000", part: "1", year: 2023, edition: 2, languages: ["en"])` now renders `IEC 1000-1:2023 ED2(en)` and yields `urn:iec:std:iec:1000-1:2023::ed-2:en`. The Hash and component forms are unchanged and still agree with the scalar form. **`number` was deliberately NOT coerced** — and the bullet below resolves that tension the other way round, by making the attribute a `:string` so a String is the type rather than a tolerated intruder. Note the copublisher renders `IEC/ISO 1000`, IEC's own ordering — the coercion does not touch order. (hand-off: iec-degenerate-component-coercion.)
 
 - **`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.)
 
-  **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. 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.
+- **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.
 
-## pubid-scheme URN (issue #670)
+- **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
 and GOST waves landed; rulings in `docs/URN-SCHEMES.adoc` (`[[urn-iec]]`).
 Invariant: every atom added after those waves sits after `database-` and
 before `lang-`, so a landed URN encodes identically (`database` became the
-bool the corpus serializes before any URN carried it). The URN inherits
-the unserialized-identity gaps pinned above: a WorkingDocument's URN is
-the type-only `urn:pubid:iec:wd` (all WD rows share one hash — a shared
-hash, not a collision), and a TestReportForm's CISPR document rides
-`cispr_identifier`. Mapping them stays the wire-format decision it
-already was.
+bool the corpus serializes before any URN carried it). The two identity
+gaps the wave inherited are closed (#687, atoms `tc-`/`wdlang-`/`wdstage-`/
+`wpstage-`/`wptype-`/`cispr-` after `vap-`, still before `lang-`): a
+WorkingDocument URNs per document instead of the shared type-only
+`urn:pubid:iec:wd`, and a TestReportForm's CISPR document nests under
+`cispr-`. All landed URNs are unchanged.

data/lib/pubid/iec/builder.rb

@@ -484,10 +484,28 @@ module Pubid
             end
           end
 
-        when :technical_committee, :subcommittee, :wd_number, :wd_stage, :wd_language, :wp_stage, :wp_type
+        when :technical_committee, :subcommittee, :wd_stage, :wd_language, :wp_stage
           # Working document/programme fields - just return as string
           value.to_s
 
+        when :wd_number
+          # The working document's own number IS the inherited `number`
+          # (issue #687, the "prefer the inherited attribute over a parallel
+          # one" rule): `root.number`, the index key and `to_hash` all read
+          # `number`, so a parallel `wd_number` attribute left every working
+          # document keyed on the empty string. The returned hash routes the
+          # value through assign_attributes onto `number`.
+          { number: value.to_s }
+
+        when :wp_type
+          # The grammar captures a trailing space ("PWI TR 100-36" → "TR ");
+          # the renderer used to strip it at print time. Strip at the
+          # construction site instead, so the stored value — and therefore
+          # to_hash and the URN — is what renders. An all-space value drops
+          # out entirely (nil is skipped by assign_attributes).
+          stripped = value.to_s.strip
+          stripped.empty? ? nil : stripped
+
         when :cispr_identifier
           # CISPR identifier object for TRF
           value