pubid 2.0.0.pre.alpha.11 → 2.0.0.pre.alpha.13

data/lib/pubid/identifier.rb

@@ -2,6 +2,9 @@
 
 module Pubid
   class Identifier < Lutaml::Model::Serializable
+    # `reference === candidate`: a subset match (see Pubid::SubsetMatch).
+    include SubsetMatch
+
     # Components that serialize as a bare scalar when they carry only their
     # single significant field: attribute name => the key the scalar is emitted
     # under. `date` is RENAMED to `year`, matching the flat shape ISO and IEC
@@ -94,7 +97,13 @@ module Pubid
         klass = concrete_class_for(data)
         return klass.from_hash(data, options) if klass && klass != self
 
-        super(inflate_scalar_components(data), options)
+        # A row written before "all parts" became a class carries the old
+        # `all_parts: true` key on the document itself. Read it, and wrap.
+        legacy_all_parts = data.is_a?(::Hash) &&
+          (data["all_parts"] || data[:all_parts])
+
+        id = super(inflate_scalar_components(data), options)
+        legacy_all_parts ? id.to_all_parts : id
       end
 
       # Accept the flat scalar form that {#to_hash} now emits, and the nested
@@ -498,9 +507,17 @@ module Pubid
     end
 
     attribute :_type, :string, polymorphic_class: true
-    attribute :number, Components::Code
-    attribute :part, Components::Code
-    attribute :subpart, Components::Code
+    # Plain strings, for every flavor. A Components::Code here held nothing
+    # but its `value` on the identifier path, and the disagreement between
+    # this declaration and the leaves that redeclared a scalar was the
+    # determinism landmine: a redeclaration on an inherited-from class
+    # resolves nondeterministically under multi-flavor load. With the base
+    # declaring the scalar, no flavor redeclares and the bug class is gone.
+    # A flavor that needs structure keeps its own attributes (ISO's committee
+    # codes, NIST's series/subseries, ITU's code), never a boxed `number`.
+    attribute :number, :string
+    attribute :part, :string
+    attribute :subpart, :string
     attribute :stage_iteration, Components::Iteration
     attribute :date, Components::Date
     attribute :edition, Components::Edition
@@ -511,7 +528,17 @@ module Pubid
     attribute :stage, Components::Stage
     attribute :locality, Components::Locality
     attribute :typed_stage, Components::TypedStage
-    attribute :all_parts, Lutaml::Model::Type::Boolean, default: false
+    # "All parts" is a class, not a flag: see {Pubid::AllParts}. These two
+    # readers keep a caller that read the old attribute working.
+    # rubocop:disable Naming/PredicateMethod
+    def all_parts
+      false
+    end
+    # rubocop:enable Naming/PredicateMethod
+
+    def all_parts?
+      false
+    end
     # base is declared by supplement subclasses with proper type
     def base
       nil
@@ -818,11 +845,15 @@ module Pubid
     #
     # This is deliberately a per-class opt-in rather than a module prepended to
     # every identifier class. That was tried: prepending to ~500 ancestor
-    # chains made a GOST identical adoption render its adopted ISO Technical
-    # Report as `ISO TR …` instead of `ISO/TR …`, but only under full-suite
-    # load — the multi-flavor nondeterminism this file warns about elsewhere.
-    # An explicit call in the handful of classes that need it changes no
-    # ancestor chain and cannot have that effect.
+    # chains correlated with a GOST identical adoption rendering its adopted
+    # ISO Technical Report as `ISO TR …` instead of `ISO/TR …`, but only under
+    # full-suite load — the multi-flavor nondeterminism this file warns about
+    # elsewhere. The correlation turned out not to be causal: the actual
+    # defect was an unrelated foreign-adoption prefix-routing race in
+    # `Gost::Builder` (`lib/pubid/gost/CLAUDE.md`), since fixed. The lesson
+    # about not prepending stands anyway: an explicit call in the handful of
+    # classes that need it changes no ancestor chain and cannot have that
+    # effect.
     #
     # @param rendered [String] the plain rendering this method produced
     # @param opts [Hash] the render options it was called with
@@ -1004,6 +1035,28 @@ module Pubid
       Pubid::UrnGenerator::Base
     end
 
+    # Attribute names on THIS class that hold a supplement's OWN identity
+    # date — e.g. an Amendment's own publication year — as distinct from the
+    # date of the document it supplements (reached one layer down, through
+    # `base`/`identifiers`). Empty by default: nothing is protected, so
+    # `exclude(:date)`/`exclude(:year)` fall straight through to every
+    # declared attribute and every nested identifier, the shape almost every
+    # flavor wants.
+    #
+    # A supplement leaf that owns its own date overrides this (CEN
+    # `Amendment` `%i[year]`, CEN `Corrigendum` `%i[year month]`, BSI
+    # `Amendment`/`Corrigendum` `%i[date]`). #exclude then protects those
+    # attributes from a bare `:date`/`:year` — recursion into a *nested*
+    # base/consolidated member is untouched, since recursion always uses the
+    # caller's original args — and requires the explicit `:supplement_year`
+    # key to clear them instead. This is what lets `exclude(:date)` on a
+    # consolidated identifier drop the base standard's date while leaving an
+    # attached amendment's own date alone, without a per-flavor #exclude
+    # override.
+    def self.supplement_date_attributes
+      []
+    end
+
     # Excluded attributes are nilled; every other value is passed through
     # #exclude_from_nested so the exclusion also propagates into nested
     # identifiers — wrapper types (adopted standards, consolidated amendments,
@@ -1023,6 +1076,16 @@ module Pubid
       # has it excluded too. The loop below nils whichever name the flavor has.
       excluded_args << :date if excluded_args.include?(:year)
 
+      own_date_attrs = self.class.supplement_date_attributes
+      # A no-op when own_date_attrs is empty (Array#|/#- with [] returns the
+      # receiver unchanged), which is every class that doesn't override the
+      # hook — no guard needed.
+      if excluded_args.include?(:supplement_year)
+        excluded_args |= own_date_attrs
+      else
+        excluded_args -= own_date_attrs
+      end
+
       attrs = self.class.attributes.each_with_object({}) do |(name, _), h|
         value = excluded_args.include?(name) ? nil : public_send(name)
         h[name] = exclude_from_nested(value, args)
@@ -1111,16 +1174,96 @@ module Pubid
       matches?(other, ignore: [:date, :year]) && self != other
     end
 
+    # The document a wrapper stands in front of: a supplement's base, or
+    # the leading member of a consolidated collection ("BS 7273-4:2015"
+    # inside "BS 7273-4:2015+A1:2021"). Nil for a plain identifier.
+    def wrapped_document
+      return base if self.class.attributes.key?(:base) && base
+
+      if self.class.collection_attribute?(:identifiers) &&
+         identifiers.is_a?(Array) && identifiers.first
+        return identifiers.first
+      end
+
+      nil
+    end
+
+    # The [publisher, number, part] tuple naming the document this
+    # identifier belongs to, resolved through wrappers.
+    def document_identity
+      wrapped_document&.document_identity || [publisher, number, part]
+    end
+
     # Self and +other+ have the same publisher + number but differ in
     # part, subpart, or edition. This is the "sibling documents" pattern:
-    # same base standard, different sub-component.
+    # same base standard, different sub-component. Two wrappers compare
+    # through the document they wrap, so e.g. the amendments of one base
+    # standard are siblings while amendments of different documents are
+    # not.
     def sibling_of?(other)
       return false unless other.is_a?(::Pubid::Identifier)
+      return false if self == other
 
-      publisher == other.publisher &&
-        number == other.number &&
-        self != other
+      if wrapped_document && other.wrapped_document
+        document_identity.take(2) == other.document_identity.take(2)
+      else
+        publisher == other.publisher &&
+          number == other.number
+      end
+    end
+
+    # The attributes that name a part of a document.
+    PART_ATTRIBUTES = %i[part subpart parts].freeze
+
+    # The class that #to_all_parts builds. A flavor with its own all-parts
+    # behaviour returns its subclass of {AllPartsIdentifier} here.
+    def self.all_parts_class
+      ::Pubid::AllPartsIdentifier
+    end
+
+    # The attributes that name an edition of a document. An all-parts
+    # identifier ignores them, so it matches every edition. #exclude skips a
+    # name that a class does not declare, so one list serves every flavor; a
+    # flavor with another edition shape overrides this.
+    def self.all_parts_edition_keys
+      %i[date year edition version]
+    end
+
+    # A new identifier for every part of this document. It holds this
+    # identifier, unchanged, as its only member. `to_s` prints the document
+    # without its part and edition ("ISO 9000 (all parts)"), and `===`
+    # matches every part of it in every edition. The receiver does not change.
+    # A parsed "(all parts)" still sets the +all_parts+ flag instead; the two
+    # forms are not equal.
+    # @return [Pubid::AllPartsIdentifier]
+    def to_all_parts
+      self.class.all_parts_class.new(identifiers: [self])
+    end
+
+    # @return [Boolean] true when this identifier names a part of a document
+    def part?
+      without_parts != normalized_copy
+    end
+
+    # A copy without `part`, `parts`, `subpart` and the +extra+ attributes.
+    # Nested identifiers lose them too (#exclude).
+    def without_parts(*extra)
+      normalized_copy(*PART_ATTRIBUTES, *extra)
+    end
+
+    # A copy without the +attrs+ (#exclude), where a part collection holds
+    # [] and never nil. A parse and #from_hash disagree on nil against [] in
+    # some flavors (JIS), so two copies compare equal only after this.
+    def normalized_copy(*attrs)
+      exclude(*attrs).tap do |id|
+        PART_ATTRIBUTES.each do |name|
+          next unless self.class.collection_attribute?(name)
+
+          id.public_send(:"#{name}=", []) if id.public_send(name).nil?
+        end
+      end
     end
+    protected :without_parts, :normalized_copy
 
     # Self is an all-parts collection that covers +other+.
     def includes?(other)
@@ -1140,15 +1283,24 @@ module Pubid
         matches?(other, ignore: [:date, :year, :stage, :typed_stage])
     end
 
-    # Self and +other+ have the same publisher + number + part but differ
-    # in edition / revision marker.
+    # Self and +other+ are editions of the same document: the edition-year
+    # pair ("ISO 9001:2008" → "ISO 9001:2015"), or two consolidated states
+    # of one base document — "BS 7273-4:2015+A1:2021" is the prior edition
+    # of "BS 7273-4:2015+A2:2023" (pubid/pubid#449). A composite and its
+    # unwrapped base are not editions of each other: bare → +A1 → +A2 is a
+    # supersession series, not an edition-year relationship — the amendment
+    # supplements the base without superseding it.
     def edition_of?(other)
       return false unless other.is_a?(::Pubid::Identifier)
+      return false if self == other
 
-      publisher == other.publisher &&
-        number == other.number &&
-        part == other.part &&
-        self != other
+      if wrapped_document && other.wrapped_document
+        document_identity == other.document_identity
+      else
+        publisher == other.publisher &&
+          number == other.number &&
+          part == other.part
+      end
     end
 
     # Any relational predicate holds.

data/lib/pubid/idf/builder.rb

@@ -13,6 +13,7 @@ module Pubid
       }.freeze
 
       def build(parsed_hash)
+        all_parts = parsed_hash.delete(:all_parts)
         typed_stage = Pubid::Idf.locate_stage(parsed_hash[:type_with_stage])
         identifier = Pubid::Idf.locate_type(typed_stage.type_code).new
 
@@ -21,7 +22,9 @@ module Pubid
         end
 
         assign_attributes(identifier, parsed_hash)
-        identifier
+        # "(all parts)" names every part of the document, so it wraps the
+        # document, which holds no mark itself.
+        all_parts ? identifier.to_all_parts : identifier
       end
 
       private
@@ -80,3 +83,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Idf::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/idf/identifier.rb

@@ -5,6 +5,18 @@ module Pubid
   module Idf
     # An IDF identifier has no copublisher
     class Identifier < ::Pubid::Identifier
+      # The all-parts identifier of this flavor.
+      def self.all_parts_class
+        Identifiers::AllParts
+      end
+
+      # A Type INSTANCE, never the raw :key symbol - lutaml materializes
+      # defaults during from_hash; casting a Symbol into the
+      # component raises InvalidFormatError (pubid#383).
+      def self.default_type
+        Components::Type.new(abbr: type[:short])
+      end
+
       attribute :typed_stage, Components::TypedStage
 
       # `number`/`part`/`subpart` are declared here rather than inherited as a

data/lib/pubid/idf/identifiers/all_parts.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    module Identifiers
+      # Every part of one IDF document: "IDF 1 (all parts)".
+      class AllParts < ::Pubid::Idf::Identifier
+        include ::Pubid::AllParts
+
+        # The document URN; GB and IDF mark no series in the URN.
+        def to_urn
+          identity.to_urn
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Pubid
   module Idf
     module Identifiers
       class Amendment < SupplementIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(

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

@@ -4,7 +4,7 @@ module Pubid
   module Idf
     module Identifiers
       class Corrigendum < SupplementIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(

data/lib/pubid/idf/identifiers/international_standard.rb

@@ -5,7 +5,7 @@ module Pubid
     module Identifiers
       # International Standard Identifier
       class InternationalStandard < SingleIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(

data/lib/pubid/idf/identifiers/reviewed_method.rb

@@ -4,7 +4,7 @@ module Pubid
   module Idf
     module Identifiers
       class ReviewedMethod < SingleIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
         TYPED_STAGES = [
           Components::TypedStage.new(
             code: :pwirm,

data/lib/pubid/idf/identifiers.rb

@@ -3,6 +3,7 @@
 module Pubid
   module Idf
     module Identifiers
+      autoload :AllParts, "#{__dir__}/identifiers/all_parts"
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :InternationalStandard,

data/lib/pubid/idf/single_identifier.rb

@@ -12,7 +12,7 @@ module Pubid
     #
     # Note: The type attribute is inherited from the base Identifier class.
     # Concrete classes should add their own default value like:
-    #   attribute :type, Components::Type, default: -> { self.class.type[:key] }
+    #   attribute :type, Components::Type, default: -> { self.class.default_type }
     class SingleIdentifier < Identifier
     end
   end

data/lib/pubid/iec/CLAUDE.md

@@ -0,0 +1,31 @@
+# IEC flavor notes
+
+IEC typed stages, `from_hash` equality, and the `number` retype that deleted `Iec::Components::Code`.
+
+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.)
+
+- **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.
+  **(2) Separator.** `SingleIdentifier#publisher_portion` printed `/` without copublishers and a space with them, while **twelve** per-type classes overrode it to force a space — so `IEC TS 60038` and `IEC DTR 62048` were already right and `IEC/CD 60038`, `IEC/FDAM 60038-1`, `IEC/DCOR 60038-1`, `IEC/DISH 60050-191` were not. The base now always uses a space (the slash stays the copublisher separator only) and **all twelve overrides are deleted**: nine of them built from `publisher.to_s` with no copublisher handling and no `super`, so deleting them **repairs** `ISO/IEC PAS 62975` → `ISO PAS 62975`, `ISO/IEC SRD 12345:2020` → `ISO SRD 12345:2020` and `IEC/IEEE SRD 62582:2022` → `IEC SRD 62582:2022` (three specs had pinned that loss). `renderer.rb#render_supplement_standalone` is a **second, independent** publisher/stage join that `publisher_portion` never reaches — it joined every part with `/` — and needed the same fix. **Input still accepts both spellings**; only rendering normalises. Measured: `to_s` changed for exactly 32 of 12,302 corpus entries, all of them the work-programme repairs above; `to_hash`, the identifier class and `root.number` are byte-identical for all 12,302.
+  **(3) URN. Do not use pubid-iec 1.x as the oracle here.** 1.x emits `urn:iec:std:iec:ts:60932:1988:::` — the type *before* the number — while all 32,831 published `relaton-data-iec` URNs put it *after* the date (`urn:iec:std:iec:60932:1988:ts::`). pubid 2's slot **order** was already right and is kept; what was missing were two slots the scrape could never reach. The layout is now `urn:iec:std:{authority}:{number}[-{part}[-{subpart}]]:{date}:{S7}:{S8}:{language}{adjuncts}`, where **S7** is `stage-{harmonized}` for a non-published stage and the legacy type token (`tr`/`ts`/`pas`/`srd`/`guide`) otherwise, and **S8** is the deliverable (`csv`/`rlv`/`exv`/`cmv`/`ser`) or, failing that, `ed-{n}`. So `IEC PNW 1000-1:2023 ED2` → `urn:iec:std:iec:1000-1:2023:stage-10.20:ed-2:`, the string the issue asked for. **A draft of a typed document keeps both, type first** (`IEC DTS 62271-1` → `ts-stage-50.00`): the harmonized codes are shared across types, so a stage-only slot would collide a draft TS, a draft TR and a draft International Standard, and `parse_urn` would resolve all three to an International Standard. Three details are load-bearing and are pinned by specs: the **authority takes the last whitespace-delimited token of a publisher body**, because `IEC CA 01:2017` is published as `urn:iec:std:ca:01:2017:::`; **`Components::Date#render` under a URN context drops the month** (the ISO convention), so the date slot reads the printed form instead and `IEC CA 01:2025-10` keeps its month; and a **deliverable is not always on the outermost wrapper** (`IEC 60079-10-1:2020 CMV/COR1:2021` is a corrigendum around the CMV), so `vap` is searched down the chain. A CISPR test report form carries no number of its own — the document sits in `cispr_identifier` — and the generator falls back to it, which is what keeps those 38 ids from losing their URN entirely.
+  **What the regex was actually costing.** Across the corpus the publisher slot held: `iec` 5,401, **nil 2,333**, **`trf` 2,142**, `iso-iec` 2,094, … `iec-pnw` 12, `iec-pwi` 9, `od` 6, `cs` 3, `ca` 3, `dir` 3. `IECEE TRF 10079-1A:2020` keyed `urn:iec:std:trf:10079-1::::` — publisher, letter part and year all gone. After the change **0 URNs are lost, 15 are gained, none gets fewer slots**, and 2,838 change, every one in the direction of carrying more identity.
+  **The published corpus changes, and that was a deliberate call.** 668 of the 32,831 published URNs no longer match, in three groups: **598** where the old `[\d-]+` stopped at a letter and took the date with it (`CISPR 11A:1976` → `urn:iec:std:cispr:11::::`, the same URN as `CISPR 11:1976`), **68** multi-deliverable ids where only the first code survived (`EXV-CMV` → `exv`), and **2** fragment identifiers that gain `ed-N`. All 668 are places where the published value is lossier than the identifier, and the measurement that justifies the change is the collision count: the published scheme puts **532 rows in 158 collision groups**, the new one **11 rows in 4**. `relaton-data-iec` therefore needs regenerating — hand-off `relaton-data-iec-regenerate-urns`.
+  **The fixture net had to be built first.** `spec/pubid/iec/fixtures_spec.rb` read `archived-gems/pubid-iec/spec/fixtures/iec-pubid.txt` at an 80% gate, with an empty failure-reporting block, so `spec/fixtures/iec/` was guarded by nothing and 35 `pass/` entries were already stale on `main`. It is rewritten on the `spec/pubid/csa/fixtures_spec.rb` shape (glob tripwire, zero-failure per file over `pass/` and `fail/`, conservation against `full/`, disjointness); note IEC's `full/` is many files, not one `identifiers.txt`, and carries the `!input!rendered` marker itself, so both sides split it. Regenerating exposed the CLAUDE.md landmine in the flesh: **five `ISO/IEC DIR …` fixtures had been hand-added to `pass/` without being added to `full/`**, and the classifier deleted them; they are restored into `full/iso-iec-pubid.txt`. The conservation example is what makes that loud from now on. (hand-off: iec-pnw-separator-urn; consumer follow-up: `relaton-data-iec` re-crawl.)
+
+- **`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.)
+
+- **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`).
+  **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.

data/lib/pubid/iec/builder.rb

@@ -28,6 +28,8 @@ module Pubid
       end
 
       def build(parsed_hash)
+        all_parts = parsed_hash.delete(:all_parts)
+
         # Handle sheet_supplement_identifier pattern:
         # {base: {...}, sheet_number: ..., sheet_year: ..., type_with_stage: "COR", number_with_part: "1", date: "1995"}
         # This is a Corrigendum/Amendment wrapping a SheetIdentifier
@@ -218,7 +220,9 @@ module Pubid
                                      vap_suffix_data)
         end
 
-        identifier
+        # "(all parts)" and the "ser" URN slot name every part of the
+        # document, so they wrap the document, which holds no mark itself.
+        all_parts ? identifier.to_all_parts : identifier
       end
 
       def handle_key(identifier, key, value)
@@ -455,3 +459,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Iec::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/iec/components/consolidated_amendment.rb

@@ -7,6 +7,8 @@ module Pubid
       # Individual Amendment within a consolidated chain
       # Single Responsibility: Represents a single amendment with number and year
       class Amendment < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :number, :string
         attribute :year, :string, default: -> {}
 
@@ -21,6 +23,8 @@ module Pubid
       # Single Responsibility: Represents multiple amendments combined with + notation
       # Example: +AMD1:2020+AMD2:2022
       class ConsolidatedAmendment < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :amendments, Amendment, collection: true
 
         def to_s

data/lib/pubid/iec/components/sheet.rb

@@ -8,6 +8,8 @@ module Pubid
       # Single Responsibility: Represents sheet number in IEC identifiers
       # Example: IEC 60695-2-1/1:1994 (where /1 is the sheet)
       class Sheet < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :number, :string
 
         def to_s

data/lib/pubid/iec/components/trf_info.rb

@@ -8,6 +8,8 @@ module Pubid
       # Single Responsibility: Represents TRF-specific publishing information
       # Example: IECEE TRF or IECEx TRF publications
       class TrfInfo < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :publisher, :string, default: -> {}
         attribute :series, :string, default: -> {}
         attribute :version, :string, default: -> {}

data/lib/pubid/iec/components/vap_suffix.rb

@@ -7,6 +7,8 @@ module Pubid
       # VAP (Validation Assessment Programme) suffix codes
       # Single Responsibility: Represents VAP validation status suffixes
       class VapSuffix < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         # VAP suffix codes as defined by IEC
         CODES = {
           "CMV" => "Common Modifications and Variations",

data/lib/pubid/iec/identifier.rb

@@ -16,7 +16,7 @@ module Pubid
     # 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 docs/flavors/iec.md.)
+    # top-level key on a wrapper; pre-existing, see lib/pubid/iec/CLAUDE.md.)
     module DelegatedFieldSuppression
       def year_to_kv(_model, _doc); end
       def publisher_to_kv(_model, _doc); end
@@ -25,6 +25,12 @@ module Pubid
     end
 
     class Identifier < ::Pubid::Identifier
+      # IEC prints "(all parts)" and has a series URN, so it has its own
+      # all-parts class.
+      def self.all_parts_class
+        Identifiers::AllParts
+      end
+
       # Override base types with IEC-specific ones. publisher defaults to the
       # type's implied publisher (IEC), so an omitted publisher key reconstructs
       # correctly on from_hash.
@@ -187,7 +193,6 @@ module Pubid
         map "stage", with: { to: :stage_to_kv, from: :stage_from_kv }
         # A Boolean attribute whose `false` default ::Pubid::Identifier#to_hash
         # already drops, so a plain map suffices (the GB spelling).
-        map "all_parts", to: :all_parts, render_default: false
       end
 
       # --- date serialized flat as year/month/day ---

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Every part of one IEC document: "IEC 80000 (all parts)".
+      #
+      # The URN is the series URN: the document URN with "ser" in the
+      # deliverable slot.
+      class AllParts < ::Pubid::Iec::Identifier
+        include ::Pubid::AllParts
+
+        def to_urn
+          ::Pubid::Iec::UrnGenerator.new(identity).generate_series
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iec/identifiers.rb

@@ -3,6 +3,7 @@
 module Pubid
   module Iec
     module Identifiers
+      autoload :AllParts, "#{__dir__}/identifiers/all_parts"
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
       autoload :Base, "#{__dir__}/identifiers/base"
       autoload :ComponentSpecification, "#{__dir__}/identifiers/component_specification"

data/lib/pubid/iec/renderer.rb

@@ -67,7 +67,6 @@ module Pubid
           parts << " DB"
         end
 
-        parts << " (all parts)" if id.all_parts
 
         result = parts.compact.join
 

data/lib/pubid/iec/urn_generator.rb

@@ -43,6 +43,14 @@ module Pubid
         "InterpretationSheet" => "ish",
       }.freeze
 
+      # The series URN of the document: "ser" takes the deliverable slot.
+      # {Identifiers::AllParts} calls it with the document, because the
+      # document itself carries no all-parts mark.
+      def generate_series
+        @series = true
+        generate
+      end
+
       def generate
         doc = document
         return nil if doc.nil?
@@ -146,7 +154,7 @@ module Pubid
       # A deliverable code owns the slot; the edition takes it only when there
       # is none.
       def deliverable_slot
-        return "ser" if maybe_of(identifier, :all_parts)
+        return "ser" if @series
 
         vap = vap_codes
         return vap unless vap.empty?

data/lib/pubid/iec/urn_parser.rb

@@ -41,7 +41,6 @@ module Pubid
         end
 
         id = Pubid::Iec::Identifier.parse(code)
-        id.all_parts = true if all_parts && id.class.attributes.key?(:all_parts)
         # The language slot joins codes with a hyphen ("en-fr"). Building one
         # Language from the whole field gave a single bogus language that
         # rendered as "(en-fr)".
@@ -50,7 +49,9 @@ module Pubid
             ::Pubid::Components::Language.new(code: code)
           end
         end
-        id
+        # The "ser" slot names every part of the document, so it wraps the
+        # document it just built.
+        all_parts ? id.to_all_parts : id
       end
 
       private