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

data/lib/pubid/bsi/urn_generator.rb

@@ -21,15 +21,15 @@ module Pubid
           parts << identifier.flex_prefix.to_s.downcase
         end
 
-        # Fall back to the wrapped document's number. A wrapper — an adopted
-        # European norm, a bundle, a set — carries no number of its own, and
-        # `AdoptedEuropeanNorm#number` only delegates ONE level, so a
-        # "DD ENV ISO 11079:1999" (which adopts a CEN prestandard that is
-        # itself a wrapper around the ISO standard) emitted the identity-free
+        # Read identity from the wrapped document when the wrapper has none of
+        # its own. A wrapper — an adopted European norm, a bundle, a set —
+        # carries no number, part, subpart or date, so a
+        # "DD ENV ISO 11079:1999" (which adopts a CEN prestandard that is itself
+        # a wrapper around the ISO standard) emitted the identity-free
         # `urn:bsi:dd` — the same URN as every other DD adoption. `#root`
         # recurses to the origin document, and for a non-wrapper it is `self`,
         # so this changes nothing for an ordinary identifier.
-        urn_number = identifier.number || identifier.root.number
+        urn_number = identity(:number)
         if urn_number
           number = urn_number.to_s
           if identifier.iteration && !identifier.iteration.empty?
@@ -38,25 +38,22 @@ module Pubid
           parts << number
         end
 
-        if identifier.part
-          part = identifier.part.to_s
-          parts << "-#{part}"
-        end
+        urn_part = identity(:part)
+        parts << "-#{urn_part}" if urn_part
 
-        if identifier.subpart
-          subpart = identifier.subpart.to_s
-          parts << "-#{subpart}"
-        end
+        urn_subpart = identity(:subpart)
+        parts << "-#{urn_subpart}" if urn_subpart
 
         if identifier.second_number
           second = identifier.second_number.to_s
           parts << "/#{second}"
         end
 
-        if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
-          parts << identifier.date.render(context: URN_CONTEXT)
-        elsif identifier.year
-          parts << identifier.year.to_s
+        urn_date = identity(:date)
+        if urn_date.is_a?(::Pubid::Components::Date) && urn_date.present?
+          parts << urn_date.render(context: URN_CONTEXT)
+        elsif (urn_year = identity(:year))
+          parts << urn_year.to_s
         end
 
         if identifier.month
@@ -87,6 +84,19 @@ module Pubid
 
         parts.join(":")
       end
+
+      private
+
+      # An identity attribute of the identifier, or of the document it wraps.
+      # `#root` is `self` for a non-wrapper, so an ordinary identifier reads its
+      # own value twice and nothing changes.
+      def identity(attr)
+        own = identifier.public_send(attr)
+        return own if own
+
+        root = identifier.root
+        root.equal?(identifier) ? nil : root.public_send(attr)
+      end
     end
   end
 end

data/lib/pubid/builder/base.rb

@@ -195,3 +195,30 @@ module Pubid
     end
   end
 end
+
+module Pubid
+  module Builder
+    # A trailing "(all parts)" is stripped by the shared Grammar and marked
+    # on the parse tree (:all_parts). Prepended to Builder::Base so every
+    # subclass — including the ones that override #build — wraps the built
+    # identifier in its flavor's all-parts class (Pubid::AllParts).
+    module AllPartsWrap
+      # Parslet tops are a Hash or an Array of Hashes (UN's multi-token tree
+      # is an Array); the marker rides every element.
+      def all_parts_marked?(data)
+        case data
+        when Hash then data[:all_parts]
+        when Array then data.any? { |e| all_parts_marked?(e) }
+        else false
+        end
+      end
+
+      def build(data, *args, **kwargs)
+        marked = all_parts_marked?(data)
+        built = super
+        marked ? built.to_all_parts : built
+      end
+    end
+
+  end
+end

data/lib/pubid/calconnect/builder.rb

@@ -36,3 +36,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Calconnect::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/calconnect/identifier.rb

@@ -18,6 +18,10 @@ module Pubid
       attribute :number, :string
       attribute :date, ::Pubid::Components::Date
 
+      # A nil `series` means the document has none: `CC 36010` is not
+      # `CC/WD 36010`, which is a working draft of it.
+      subset_strict :series
+
       # Polymorphic type map for lutaml::Model key_value (de)serialization,
       # mapping the concrete class's polymorphic_name to its class name so a
       # stored hash rebuilds the correct identifier type via from_hash.

data/lib/pubid/ccsds/builder.rb

@@ -55,3 +55,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Ccsds::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/ccsds/identifier.rb

@@ -22,11 +22,23 @@ module Pubid
       # are likewise CCSDS-specific plain strings.
       attribute :number, :string
       attribute :part, :string
+      # CCSDS never populates `subpart`, but the inherited declaration is a
+      # Components::Code, and a parent that disagrees with its leaves is the
+      # determinism landmine. Declare it here, like every converted flavor.
+      attribute :subpart, :string
       attribute :edition, :string
       attribute :type, :string
       attribute :suffix, :string
       attribute :language, :string
 
+      # A nil `language` means the original English document, not any
+      # translation: `CCSDS 650.0-M-2` is not its French translation.
+      subset_strict :language
+
+      # A nil `suffix` means the current document, not its historical `-S`
+      # version: `CCSDS 101.0-B-4` is not `CCSDS 101.0-B-4-S`.
+      subset_strict :suffix
+
       # Polymorphic type map for lutaml::Model key_value (de)serialization,
       # mapping each concrete class's polymorphic_name to its class name.
       CCSDS_TYPE_MAP = {

data/lib/pubid/ccsds/single_identifier.rb

@@ -9,10 +9,14 @@ module Pubid
       attribute :publisher, Components::Publisher, default: -> {
         Components::Publisher.new(body: "CCSDS")
       }
-      attribute :series, Components::Code
-      attribute :number, Components::Code
-      attribute :part, Components::Code
-      attribute :book_color, Components::Code
+      # Plain :string, like the live Pubid::Ccsds::Identifier hierarchy, which
+      # already declared these as strings. This class is otherwise
+      # unreferenced — nothing inherits it and no builder instantiates it — but
+      # it is public API, so it is retyped rather than deleted.
+      attribute :series, :string
+      attribute :number, :string
+      attribute :part, :string
+      attribute :book_color, :string
       attribute :edition, Components::Edition
       attribute :retired, :boolean, default: -> { false }
       attribute :language, Components::Language
@@ -29,14 +33,14 @@ module Pubid
         result += " "
 
         # Series (optional single letter before number)
-        result += series.value if series
+        result += series.to_s if series
 
         # Number with part (using dot notation)
-        result += number.value
-        result += ".#{part.value}" if part
+        result += number.to_s
+        result += ".#{part}" if part
 
         # Book color (required) - no space before dash
-        result += "-#{book_color.value}" if book_color
+        result += "-#{book_color}" if book_color
 
         # Edition (optional)
         result += "-#{edition.number}" if edition
@@ -54,11 +58,11 @@ module Pubid
         return nil unless other.is_a?(SingleIdentifier)
 
         # Compare by number first
-        num_cmp = number.value.to_i <=> other.number.value.to_i
+        num_cmp = number.to_i <=> other.number.to_i
         return num_cmp unless num_cmp.zero?
 
         # Then by part
-        part_cmp = (part ? part.value.to_i : 0) <=> (other.part ? other.part.value.to_i : 0)
+        part_cmp = part.to_i <=> other.part.to_i
         return part_cmp unless part_cmp.zero?
 
         # Then by edition

data/lib/pubid/cen_cenelec/CLAUDE.md

@@ -0,0 +1,59 @@
+# CEN/CENELEC flavor notes
+
+CEN/CENELEC supplements, adopted norms, equality and the relaton matching contract.
+
+Read these notes before you change `lib/pubid/cen_cenelec/` or `spec/pubid/cen_cenelec/`. The root `CLAUDE.md` keeps the cross-flavor contract that every flavor obeys.
+
+- **Six defects blocked the relaton CEN migration, and the parse was not one of them.** The relaton CEN flavor scrapes `standards.cencenelec.eu` and has no index, so it needs only `parse`, `exclude` and `matches?`. 63 of its 67 references rendered correctly, but the other surfaces failed: (1) `ENV 1613:1995` and `ES 59008:2000` rendered as `ENV/ENV …` and `ES/ES …`, because the renderer knew only CWA, HD and CR as publisher-types (BSI inherited it: `DD ENV 206:1992`, `PD ES 59008-1:2000`); (2) every consolidated identifier (`EN 285:2015+A1:2021`) raised on `exclude`, `to_hash` and `matches?`; (3) an adopted norm lost its CEN supplement (`CEN ISO/TS 21003-7:2008/A1:2010` → `CEN ISO/TS 21003-7:2008`, and 8 fixture lines such as `EN ISO 13485:2016/AC:2016`); (4) `to_hash` raised on every supplement and on every adopted norm; (5) **any two amendments were `==`**, so `matches?` on an amendment was always true; (6) `from_hash` raised on every CWA, HD, CR, ES and ENV document. The single constant `Pubid::CenCenelec::PUBLISHER_TYPES` (`CWA HD ES CR ENV`) now drives both the builder's class choice and the renderer. `spec/pubid/cen_cenelec/relaton_blockers_spec.rb` locks all six. (hand-off: `metanorma__pubid__cen-cenelec-relaton-blockers`.)
+- **The supplements left the legacy `Identifiers::Base`.** `Amendment`, `Corrigendum`, `Fragment` and `ConsolidatedIdentifier` descended from `Identifiers::Base`, which declares a `publisher` String collection, `year`, `parts`, `type` and a hand-written `==` that compared only publisher, number, parts and year. A supplement sets none of those, so `EN 13250:2000/A1:2005 == EN 99999:1990/A7:1991` was true. They now descend from the shared `Pubid::CenCenelec::Identifier`, and `base`/`identifiers` are typed to that class (polymorphic), so a base can be a `SingleIdentifier`, an adopted norm or another supplement. The custom `==` is deleted; lutaml's attribute-wise `==` compares the whole object. `Identifiers::Base` itself stays, because it is Category B (`spec/pubid/identifier_hierarchy_spec.rb`), but no concrete type descends from it now. The top-level `SupplementIdentifier` (a subclass of it that no builder created) and its `UrnGenerator#generate_supplement_urn` branch were deleted: both still read the old `amendment_number`/`amendment_year` names. **The `:human` format registry moved to `Pubid::CenCenelec::Identifier`**: it was registered on `SingleIdentifier` and `Identifiers::Base` only, so a re-parented supplement rendered as `""`.
+- **The deleted readers were the landmine, not a convenience.** `ConsolidatedIdentifier` defined `publisher`, `number`, `year`, `parts` and `type` readers that delegated to the first member, and `AdoptedEuropeanNorm` defined `number`, `year`, `date`, `parts` and `part` readers that delegated to the ISO/IEC document. Each name is a lutaml attribute, and `#exclude` and the serializer read every attribute through its reader: the consolidated one reached `EuropeanNorm#parts`, which does not exist, and the adopted one wrote the ISO values a second time at the top level of the hash. Read the document through `#base_document`, `#drop_supplements` or `#root` instead. The supplements expose `supplement_type`, and their ordinal and year as plain `number` / `year` — the same names BSI's supplements use (the `supplement_number` / `supplement_year` aliases were deleted; see the matching-primitives bullet in CLAUDE.md). **Consequence:** a supplement's own `publisher` is now nil; use `base_document.publisher`.
+- **BSI read through the deleted readers.** `Bsi::Identifiers::AdoptedEuropeanNorm#number` (and `year`, `date`, `parts`, `part`) delegated to its adopted document, and for `BS EN ISO 11819-1:2023` that document is a CEN adoption, whose number came from the deleted reader. A private `delegate_target` now reads through the CEN adoption to the ISO standard. `subpart` keeps reading the CEN object, as before. A replay of all 1,501 BSI pass fixtures against `main` gave byte-identical `to_s`, `to_urn`, `to_mr_string`, class and `root.number`, except 5 repaired doubled publishers and 2 fragments (`BS EN IEC 61535/AMD1/FRAG1`) whose `root.number` changed from `"1"` to `"61535"`.
+- **The year rule is BSI's, plus a CEN key (decided with the user).** `exclude(:year)` removes only the base document's year: `EN 13250:2000/A1:2005` → `EN 13250/A1:2005`, `EN 285:2015+A1:2021` → `EN 285+A1:2021`. The key `:supplement_year` removes the supplement's own date instead, and the month goes with the year, so a `/AC:2016-11` does not keep a month with no year. ISO and IEC behave differently: there each layer keeps its year in `date`, so `exclude(:year)` removes every year. The CEN rule lets relaton keep the base year strict and make the amendment year optional. **The mechanism used to be a per-flavor `#exclude` override; it is now the shared base class** (`metanorma__pubid__exclude-recursion-depth` hand-off, `lib/pubid/bsi/CLAUDE.md`'s "The `exclude` recursion boundary"). `::Pubid::Identifier#exclude` itself now protects the attributes a class names in `self.supplement_date_attributes` (`%i[year]` on `Amendment`, `%i[year month]` on `Corrigendum`, empty on a document — and empty on every flavor that doesn't override it, so this is a no-op everywhere else) from a bare `:date`/`:year`, or clears them instead when `:supplement_year` is passed. `Pubid::CenCenelec::Identifier#exclude` was deleted; the base #exclude still passes every key on to nested identifiers, so the members of a consolidated identifier follow the rule. **relaton ignore mapping**: a query with no part adds `%i[part subpart]`, a query with no base year adds `:year`, a query with no amendment year adds `:supplement_year`; `exclude(:year, :supplement_year)` gives the fully undated `EN 285+A1`.
+- **The builder has one supplement path.** `Builder#build` builds the base document first (`build_base_document`: adopted norm, ENV adoption, implicit IEC adoption or plain identifier), then wraps it: a `/` supplement makes a standalone `Amendment`/`Corrigendum`, a `+` supplement makes a `ConsolidatedIdentifier`. The adopted branches used to return early, which is how they lost the supplement. The implicit IEC adoption (`EN 60xxx` → `EN IEC 60xxx`) now runs only when there is no supplement, because it rebuilds the identifier from the bare number and dropped a `+A1` the same way. An empty captured number or month is stored as nil (`present_string`), because `to_hash` drops `""` and `from_hash` then gives nil. A mixed `/` and `+` form keeps only the first `/` supplement; that gap is older than this change and is not fixed.
+- **The adopted norm holds a `Components::Publisher`.** The builder passed `publisher: ["EN"]`, an Array, into a `Components::Publisher` attribute, and the renderer joined it; `to_hash` raised and the URN and MR printed the Array's `inspect`. The second publisher of a `CEN/CLC` adoption goes in `copublishers`, set only when present (an empty collection becomes nil after a round trip). `lib/pubid/bsi/builder.rb` constructs this class too and now takes the `EN` default. An ENV adoption (`ENV ISO 11079:1999`) now carries the publisher `ENV`, not the `EN` default.
+- **A CEN supplement's year is a string.** `year` is `"2005"`, not `2005`, since it became a `:string` attribute (see the wire-shape bullet below). BSI's supplements were later aligned to the same type, so a caller comparing years across the two flavors compares like with like.
+- **A publisher-type does not write its publisher (decided with the user).** `SingleIdentifier.default_publisher` is the type token for the five `PUBLISHER_TYPES` classes (`CenWorkshopAgreement` CWA, `HarmonizationDocument`/`CenelecHarmonizationDocument` HD, `CenReport` CR, `EuropeanSpecification` ES, `EuropeanPrestandard` ENV) and EN for every other class. `to_hash` leaves out a value equal to its default, so `CWA 14050-21:2000` is `{"_type" => "…cen-workshop-agreement", "number" => "14050", "part" => "21", "year" => "2000"}`: `_type` already names the publisher. An adopted norm is a European Norm, so `HD IEC 60364-8-81` and `CR ISO 13434:1999` still write `"publisher" => "HD"`/`"CR"`, and a TR, TS or Guide still writes `CEN` or `CLC`, which is real information. After this, every key left in a CEN hash carries information.
+- **A draft stage serializes as one code (decided with the user).** `prEN 1234:2020` wrote three nested components, `type`, `stage` and `typed_stage`, each a copy of one entry of the stage registry (with its name and harmonized stages). It now writes `"stage" => "pren"` (`fpren` for FprEN), as ISO (`"dis"`) and IEC (`"cd"`) do. `Pubid::CenCenelec::Identifier.compact_hash` writes the short form only when the three components are exactly what the registry entry gives, so the round trip stays exact; `inflate_scalar_components` rebuilds them with `CenCenelec.locate_stage_by_code`, and the nested form still reads. `compact_hash` is a new class hook on `Pubid::Identifier` (no-op by default) that the canonicalizer calls for every identifier, nested ones included, so the stage of a `base` is short too. **The slug now names the stage**: `prEN 1234:2020` and `FprEN 1234:2020` both slugged `en.en.1234.2020` (the shared `mr_type` gives the type code `en`); a CEN `mr_type` override gives `en.pren.1234.2020` and `en.fpren.1234.2020`. **An adoption keeps its draft stage**: `prEN ISO 1234:2020` rendered as `EN ISO 1234:2020`, because `build_adopted_identifier` dropped the `type_with_stage` capture. It now stores the three stage components, the renderer prints `prEN` in place of the publisher, and the URN appends the stage as the base URN does (`urn:cen:en:iso:1234:2020:stage.proposal`).
+- **The adopted document is `adopted`, in CEN and BSI together (decided with the user).** CEN `AdoptedEuropeanNorm`/`EuropeanPrestandard` (and the unused legacy `Identifiers::Base`) and BSI `AdoptedEuropeanNorm`/`AdoptedInternationalStandard` renamed `adopted_identifier` to `adopted`, the name GOST `IdenticalAdoption` already used; one rename across both flavors keeps a BSI-over-CEN chain on one name (`BS EN ISO 11819-1:2023` → `bsi.adopted.adopted`). The hash key follows (`"adopted" => {…}`). Nothing outside pubid read the old name and no published index stored it, so no alias is kept. The collections GOST `Harmonized#adopted_identifiers` and IEEE `AdoptedStandard#adopted_identifiers` keep their name: `relaton-data-ieee` stores 64 rows with that key.
+- **The `type` default of a typed leaf is a component.** Nine leaves declared `default: -> { self.class.type[:key] }`, a bare Symbol such as `:cwa`, in a `Components::Type` attribute. `to_hash` dropped it as a default, and `from_hash` raised when it cast the Symbol. `SingleIdentifier.default_type` returns `Components::Type.new(abbr: type[:short])`, the same value the parser sets for `CEN/TR`. `to_hash` still omits it, and now also omits the `type` of TR, TS and Guide, which equals the default. No CEN index exists, so no stored row changes.
+- **The wire shape is flat (decided with the user).** A supplement uses the same keys as a document: the inherited `number` holds the amendment, corrigendum or fragment number, and `year`/`month` are `:string` attributes (they were `amendment_number`, `amendment_year`, `corrigendum_*` and `fragment_number`, with Integer years). `EN 13250:2000/A1:2005` → `{"_type" => "…amendment", "base" => {…, "number" => "13250", "year" => "2000"}, "number" => "1", "year" => "2005"}`; `…/AC:2016-11` adds `"month" => "11"`. The `publisher` is a bare string and `copublishers` a list of strings (`"publisher" => "CEN", "copublishers" => ["CLC"]`). **This is CEN-only on purpose.** `Pubid::Identifier.flat_scalar_components`/`flat_scalar_fields` are now class methods over the shared tables, and `Pubid::CenCenelec::Identifier` merges `publisher`/`copublishers` into them; the shared canonicalizer gained collection support for this. A shared entry would also flatten ANSI, BSI, IDF and some IEEE hashes, and `relaton-data-ieee` is a published index. `from_hash` still reads the nested `{"body" => …}` form. A base document with a month still writes `"date" => {"year", "month"}`, because only a single-field component flattens. **A consolidated identifier writes its base once**: the members after the first carry no `base` (the builder used to copy it into each), so `EN 285:2015+A1:2021` is `{"identifiers" => [{EN 285:2015}, {"_type" => "…amendment", "number" => "1", "year" => "2021"}]}`. A member's `base_document` is therefore itself; walk the consolidated identifier instead.
+- **URN and MR of the wrappers are new.** Every amendment had the URN `urn:cen:en`, and the 165 distinct fixture identifiers had only 130 distinct URNs. Now: `EN 13250:2000/A1:2005` → `urn:cen:en:13250:2000:amd:1:2005` / `en.13250.2000_amd.1.2005`; `EN 285:2015+A1:2021` → `urn:cen:en:285:2015:plus:amd:1:2021` / `en.285.2015_plus-amd.1.2021` (the `plus` marker, as in IEC, keeps it apart from the standalone `/A1:2021`); `EN 60038 AMD1 FRAG2` → `…:amd:1:frag:2`; an adoption uses its publisher and the adopted document's MR string (`CEN ISO/TS 21003-7:2019` → `urn:cen:cen:iso:ts:21003-7:2019` / `cen.iso.ts.21003-7.2019`). An unnumbered corrigendum has no number segment (`EN 13254:2000/AC:2003` → `…:cor:2003`). Over the fixture corpus, 187 distinct identifiers now give 187 distinct slugs and URNs.
+- **The fixture spec was dead.** `spec/pubid/cen_cenelec/fixtures_spec.rb` globbed `../../../fixtures/…` and ran 0 examples. It now has the `spec/pubid/csa/fixtures_spec.rb` shape (tripwire, zero failures per file, conservation against `full/*.txt`). `full/cen.txt` now carries the relaton corpus. The three grammar gaps `prEN 13306 rev`, `prEN 285 rev` and `EN 285:2015/FprA1` are recorded in `fail/`; relaton skips them, because they are catalogue hits and not caller references. The regeneration also rewrote the `fail/` class column to `Pubid::Errors::ParseError`.
+- **`Pubid::TypeResolver` could not resolve a CEN `_type`, which was older than the blocker fixes.** The polymorphic name is `pubid:cencenelec:…` (the module name), but the registry knows the flavor only as `cen_cenelec` and `cen`, so `Pubid::Registry.get("cencenelec")` was nil. `Pubid::CenCenelec::Identifier.from_hash` worked, because the flavor's own `polymorphic_type_map` resolves the type first, but `Pubid::Identifier.from_hash` on a CEN hash and a CEN identifier nested in another flavor's `::Pubid::Identifier` attribute (BSI `AdoptedEuropeanNorm#adopted`) deserialized as the abstract root. The flat publisher made this visible: the root cannot cast `"CEN"` into a `Components::Publisher`, so the wrong result became a raise. `TypeResolver#flavor_by_module_segment` now falls back to the registered module whose constant gives the segment; CEN is the only flavor with the mismatch (3GPP forces `pubid:3gpp:`). BSI round trips over its pass fixtures went from 815 to 865, and `KNOWN_ROUND_TRIP_FAILURES` for BSI from 647 to 597.
+- **Still open, pinned nowhere as correct:** `HD IEC 60364-8-81 ED1` drops `ED1`; `EN 60038 AMD1 FRAG2` renders as `EN 60038/A1 FRAG2`; `root.number` of an adopted norm is the ISO `Components::Code` until ISO is retyped (tranche 3 of the `number` retype).
+
+## CEN is the remaining `adopted` camp
+
+BSI moved its adoption wrappers to the uniform `base` accessor (`lib/pubid/bsi/CLAUDE.md`); CEN did not, and this records the shape so the next branch does not have to re-survey it.
+
+Three classes still name the parent slot `adopted`:
+
+- `Identifiers::AdoptedEuropeanNorm` and `Identifiers::EuropeanPrestandard` — both carry a hand-written `#root` walking `adopted`, and an `mr_number_with_part` that puts `adopted.to_mr_string` where the number goes. So the index key and the slug are correct; only the accessor's name diverges, and `id.base` reads nil on both.
+- `Identifiers::Base`, the legacy second root — its `adopted` is typed to CEN's own `Base`, **not** `::Pubid::Identifier`, so it cannot hold a cross-flavor adoption at all, and it has no `#root`. It is rarely instantiated (`SingleIdentifier` is the live branch), which is why nothing has tripped over the narrow type.
+
+CEN is a harder rename than BSI was for one reason: `Pubid::Bsi::Builder` constructs a `CenCenelec::Identifiers::AdoptedEuropeanNorm.new(adopted: …)`, and `Bsi::Identifiers::AdoptedEuropeanNorm` used to read `target.adopted` through one CEN layer. The first of those two call sites is still there.
+
+Note the asymmetry a rename must preserve: a BSI `AdoptedEuropeanNorm` now exposes `base`, and the CEN object it holds still exposes `adopted`, so a two-layer walk reads `id.base.adopted`. `#root` recurses through both regardless, which is why it — and not a delegation — is the right thing for a consumer to call.
+
+## Subset match: strict attributes
+
+Read `docs/SUBSET_MATCH.md` first. `===` reads a nil part of the reference as
+a wildcard, which is wrong for the attributes below: the flavor models a nil
+value as "this document has none". They are declared with `subset_strict`, so
+`===` compares them exactly and a stated collection is not a prefix. A caller
+that does want every part of a document sets `all_parts` on the reference, or
+keeps `#matches?(other, ignore:)`.
+
+- **`type`, `stage` and `typed_stage` are strict**
+  (`lib/pubid/cen_cenelec/identifier.rb`). A published European Norm holds
+  all three at nil, so a nil one means "published", not "any stage":
+  `EN 1325 === prEN 1325` and `EN 1991 === ENV 1991-2-2` are both false,
+  while `EN 1325 === EN 1325:2001` still holds. The three move together
+  because they repeat one entry of the stage registry — the same fact that
+  lets `compact_hash` write them as a single `"stage" => "pren"` and
+  `inflate_scalar_components` read them back, which is why the strict
+  comparison survives a `from_hash` round trip.
+- The hand-off `subset-match-nil-means-none` called this a CEN-grammar
+  decision, on the reading that a published norm should carry a published
+  stage by default. It is fixed at the matching layer instead: no grammar
+  change, no index re-crawl.

data/lib/pubid/cen_cenelec/builder.rb

@@ -95,10 +95,13 @@ module Pubid
         base = locate_identifier_klass(base_data).new
         assign_attributes(base, base_data)
 
-        # Build Amendment identifier wrapping the base
+        # Build Amendment identifier wrapping the base. The compact
+        # fragment spelling can carry the amendment's own year
+        # (EN 60038/A1:2009 FRAG2); the AMD-keyword spelling cannot.
         amendment = Identifiers::Amendment.new(
           base: base,
           number: data[:amendment_number].to_s,
+          year: data[:amendment_year]&.to_s,
         )
 
         # Build Fragment wrapping the amendment
@@ -385,3 +388,5 @@ module Pubid
     end
   end
 end
+
+Pubid::CenCenelec::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/cen_cenelec/identifier.rb

@@ -20,6 +20,12 @@ module Pubid
       attribute :part, :string
       attribute :subpart, :string
 
+      # A published European Norm holds no type, stage or typed stage, so a
+      # nil one means "published", not "any stage": `EN 1325` is not
+      # `prEN 1325`, and `EN 1991` is not `ENV 1991`. The three components
+      # repeat one entry of the stage registry, so they move together.
+      subset_strict :type, :stage, :typed_stage
+
       # The publisher serializes as a bare string ("publisher" => "CEN"), and
       # the copublishers as a list of strings. The shared table does not do
       # this for every flavor, because IEEE has a published index whose rows
@@ -81,33 +87,10 @@ module Pubid
         stage.code.to_s.downcase
       end
 
-      # The attributes that hold a supplement's own date: `year`, and `month`
-      # on a corrigendum. Empty for a document. See #exclude.
-      def self.supplement_date_attributes
-        []
-      end
-
-      # The CEN year rule, as in BSI: `:year` removes only the base
-      # document's year ("EN 13250:2000/A1:2005" -> "EN 13250/A1:2005"), and
-      # the CEN key `:supplement_year` removes the supplement's own date
-      # ("EN 13250:2000/A1"). A supplement declares its date as a `year`
-      # attribute, which the base #exclude resets for `:year`, so the value is
-      # put back here. The month goes with the year, or a "/AC:2016-11" would
-      # keep a month with no year. The base #exclude passes every key on to
-      # the nested identifiers, so the members of a consolidated identifier
-      # follow the same rule.
-      def exclude(*args)
-        result = super
-        attrs = self.class.supplement_date_attributes
-        # `exclude(:amendment)` returns the base document, not a copy of self.
-        return result if attrs.empty? || !result.instance_of?(self.class)
-
-        drop = args.include?(:supplement_year)
-        attrs.each do |attr|
-          result.public_send(:"#{attr}=", drop ? nil : public_send(attr))
-        end
-        result
-      end
+      # The CEN year rule (`:year` vs `:supplement_year`) is the shared
+      # `::Pubid::Identifier#exclude` mechanism driven by `Amendment`'s and
+      # `Corrigendum`'s `supplement_date_attributes` — no override needed
+      # here. Detail: `lib/pubid/cen_cenelec/CLAUDE.md`'s year-rule bullet.
 
       def self.parse(identifier)
         unless identifier.is_a?(String)

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

@@ -36,20 +36,13 @@ module Pubid
           base || self
         end
 
-        # Uniform supplement interface (shared with Corrigendum and with BSI)
-        # so callers need not special-case the class.
+        # Names the supplement class, so callers need not special-case it. The
+        # ordinal and the year need no such method: Amendment and Corrigendum —
+        # in CEN and in BSI — all declare them as `number` and `year`.
         def supplement_type
           :amendment
         end
 
-        def supplement_number
-          number
-        end
-
-        def supplement_year
-          year
-        end
-
         def mr_supplement_suffix
           mr_join_segments("amd", number, year)
         end

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

@@ -29,20 +29,13 @@ module Pubid
           base || self
         end
 
-        # Uniform supplement interface (shared with Amendment and with BSI)
-        # so callers need not special-case the class.
+        # Names the supplement class, so callers need not special-case it. The
+        # ordinal and the year need no such method: Amendment and Corrigendum —
+        # in CEN and in BSI — all declare them as `number` and `year`.
         def supplement_type
           :corrigendum
         end
 
-        def supplement_number
-          number
-        end
-
-        def supplement_year
-          year
-        end
-
         # The date part of the supplement: "2016-11", "2003", or nil.
         def supplement_date
           return nil unless year

data/lib/pubid/cen_cenelec/parser.rb

@@ -91,12 +91,20 @@ module Pubid
       # Edition (ED2, ED3, etc.)
       rule(:edition) { space >> str("ED") >> digits.as(:edition) }
 
-      # Fragment identifier (EN 60038 AMD1 FRAG2)
+      # Fragment identifier (EN 60038 AMD1 FRAG2, EN 60038/A1 FRAG2)
       rule(:fragment_identifier) do
-        (stage_prefix | publisher) >>
+        ((stage_prefix | publisher) >>
           space >> number >> parts >>
           space >> str("AMD") >> digits.as(:amendment_number) >>
-          space >> str("FRAG") >> digits.as(:fragment_number)
+          space >> str("FRAG") >> digits.as(:fragment_number)) |
+          # Compact supplement notation: the base may carry a year, the
+          # amendment uses the /A1 or +A1 join (with an optional year of
+          # its own) instead of the spelled-out "AMD1" keyword.
+          ((stage_prefix | publisher) >>
+            space >> number >> parts >> year.maybe >>
+            (plus | slash) >> str("A") >> digits.as(:amendment_number) >>
+            (colon >> digit.repeat(4, 4).as(:amendment_year)).maybe >>
+            space >> str("FRAG") >> digits.as(:fragment_number))
       end
 
       # Adopted standard as opaque string - must start with org name

data/lib/pubid/cie/CLAUDE.md

@@ -0,0 +1,58 @@
+# CIE flavor notes
+
+CIE builder attribute assembly.
+
+Read this before you change `lib/pubid/cie/` or `spec/pubid/cie/`. The root
+`CLAUDE.md` keeps the cross-flavor contract that every flavor obeys.
+
+- **The builder offered every CIE type the same attribute hash, and the types
+  do not share one attribute set.** `Builder#extract_attributes` unconditionally
+  set `attributes[:s_prefix]`, but only `Standard`, `DualPublished` and
+  `Identical` declare that attribute — `Conference`, `Bundle`, `Proceedings`,
+  `Supplement` and `TutorialBundle` do not. lutaml reads only declared
+  attribute names out of a constructor hash and reports nothing about the rest,
+  so the surplus key was discarded in silence and nothing failed.
+
+  It stopped being silent when `::Pubid::Identifier` began **refusing** an
+  unknown constructor key (the cross-flavor contract in the root `CLAUDE.md`):
+  **94 CIE identifiers immediately stopped parsing** with
+  `ArgumentError: unknown attribute for Pubid::Cie::Identifiers::Conference:
+  s_prefix` — every `CIE x005-1992`-style conference paper and every
+  comma-list bundle. The fix is one line in `lib/pubid/cie/builder.rb`:
+  select the assembled attributes down to those the chosen
+  `identifier_class` actually declares, immediately before `new`.
+
+  **The lesson is about where to filter, not about `s_prefix`.** A builder that
+  assembles one hash for a family of types must narrow it per type; the
+  alternative — letting the constructor drop what it does not recognise — is
+  exactly the silence that hid this. `Pubid::Builder::Base#assign_attributes`
+  already documents "silently skips unknown attributes" for the same reason,
+  but CIE's builder constructs directly and so bypassed it.
+
+  Locked by `spec/pubid/attribute_construction_spec.rb` ("builders offer only
+  declared attributes"), which parses a conference paper, a bundle and an
+  `s_prefix`-bearing standard, and asserts `Conference` still does **not**
+  declare `s_prefix` — so re-adding the attribute to silence the spec would
+  turn it red rather than green.
+
+- **All 10 CIE types rendered plain under `to_s(annotated: true)`.** Every
+  one composes its own string instead of going through `render`, so none
+  reached the shared annotation hook; each now calls
+  `annotate_plain_render` on the way out.
+
+  **`Standard` needed more than a wrap.** Its body has three exits — the
+  `slash_colon` language form and the legacy bare slash-year form both
+  `return` early — and `annotate_plain_render` needs one. The composition
+  moved verbatim into a private `render_plain`; `to_s` is two lines. The
+  trap is the `private` keyword: written as a **section** it privatises
+  every method below it, which swallowed `mr_type` — a public method the
+  MR renderer calls. The section goes at the **end** of the class.
+  `Bundle` keeps its `return "" unless ids&.any?` guard and wraps only the
+  composed value.
+
+  **`Supplement` was a different bug with the same symptom.** It is a
+  wrapper: `number` is the supplement ordinal (`"1"`, which does not stand
+  alone in `CIE 121-SP1:2009`) and the document's identity — number `121`,
+  year `2009` — lives on `base`. Wrapping its `to_s` changed nothing,
+  because the annotator only read the wrapper's own attributes. It is fixed
+  by `Annotator#emit_tokens` walking `base`, not by anything in CIE.

data/lib/pubid/cie/builder.rb

@@ -522,3 +522,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Cie::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/cie/components/language.rb

@@ -12,6 +12,8 @@ module Pubid
       # 3. Parenthetical: (DE), (ES), (en)
       # 4. Translation year: (RU-2021)
       class Language < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :code, :string              # "E", "DE", "RU", "en"
         attribute :format, :string            # "slash", "slash_colon", "paren", "paren_year"
         attribute :translation_year, :string  # "2021" in "(RU-2021)"

data/lib/pubid/components/adoption.rb

@@ -28,6 +28,8 @@ module Pubid
     # the prefix and any suffix notation (translation, reaffirmation,
     # commentary) by calling adoption.render(context:).
     class Adoption < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
       attribute :base, ::Pubid::Identifier, polymorphic: true
       attribute :adopter_publisher, ::Pubid::Components::Publisher
       attribute :edition, :string

data/lib/pubid/components/code.rb

@@ -10,6 +10,8 @@ module Pubid
     # composition rules — flavor-specific separators and orderings live in
     # the subclass #to_s / #render override.
     class Code < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
       attribute :value, :string
       attribute :prefix, :string
       attribute :part, :string

data/lib/pubid/components/date.rb

@@ -12,6 +12,8 @@ module Pubid
     # URN spec); flavors that drop the slot when undated gate that decision
     # at the URN-generator level, not here.
     class Date < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
       attribute :year, :string
       attribute :month, :string
       attribute :day, :string
@@ -51,12 +53,6 @@ module Pubid
         result
       end
 
-      private
-
-      def pad2(value)
-        value.to_s.rjust(2, "0")
-      end
-
       def hash
         @hash ||= [year, month, day, undated].compact.map(&:hash).hash
       end
@@ -67,6 +63,12 @@ module Pubid
         year == other.year && month == other.month && day == other.day &&
           undated == other.undated
       end
+
+      private
+
+      def pad2(value)
+        value.to_s.rjust(2, "0")
+      end
     end
   end
 end

data/lib/pubid/components/edition.rb

@@ -7,6 +7,8 @@ module Pubid
     # Human render: "ED#{number}".
     # URN render: "ed-#{number}" per RFC 5141-bis.
     class Edition < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
       attribute :year, :string
       attribute :number, Lutaml::Model::Type::Value
       attribute :original_text, :string

data/lib/pubid/components/iteration.rb

@@ -8,6 +8,8 @@ module Pubid
     # because URN, MR, and human formats position iteration differently
     # relative to the stage abbreviation.
     class Iteration < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
       attribute :number, :string
 
       def to_s

data/lib/pubid/components/language.rb

@@ -7,6 +7,8 @@ module Pubid
     # Human render: language code, optionally single-char.
     # URN render: lowercase ISO 639-1 code (RFC 5141-bis).
     class Language < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
       CHAR_MAP = {
         "R" => "ru",
         "F" => "fr",

data/lib/pubid/components/locality.rb

@@ -7,6 +7,8 @@ module Pubid
     # Renders the human-readable phrase "(all parts)" and a URN
     # suffix that completes the locality segment.
     class Locality < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
       attribute :value, :string
 
       def render(context: nil)

data/lib/pubid/components/publisher.rb

@@ -9,6 +9,8 @@ module Pubid
     # Human render: the publisher body (e.g. "ISO").
     # URN render: lowercase body (e.g. "iso") per RFC 5141-bis.
     class Publisher < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
       attribute :body, :string
 
       def to_s

data/lib/pubid/components/relationship.rb

@@ -21,6 +21,8 @@ module Pubid
     # - approved_amendments_flag: when true and no intermediate_amendments
     #   are listed, renders "... and its approved amendments".
     class Relationship < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
       REVISION_OF = "revision_of"
       AMENDMENT_TO = "amendment_to"
       CORRIGENDUM_TO = "corrigendum_to"