pubid 2.0.0.pre.alpha.12 → 2.0.0.pre.alpha.13

data/lib/pubid/ccsds/identifier.rb

@@ -31,6 +31,14 @@ module Pubid
       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/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"

data/lib/pubid/components/stage.rb

@@ -9,6 +9,8 @@ module Pubid
     # Human render: abbreviation with flavor-specific separator.
     # URN render: stage abbreviation alone (no separator).
     class Stage < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
       attribute :name, :string
       attribute :stage_code, :string
       attribute :harmonized_stages, :string, collection: true

data/lib/pubid/components/supplement.rb

@@ -26,6 +26,8 @@ module Pubid
     # order they appear in the printed supplement; the URN form joins number
     # and year with ":".
     class Supplement < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
       DEFAULT_TYPE = "sup"
 
       attribute :type, :string, default: -> { DEFAULT_TYPE }

data/lib/pubid/components/type.rb

@@ -9,6 +9,8 @@ module Pubid
     # Human render: abbreviation with flavor-specific separator.
     # URN render: type code (e.g. "tr", "ts") per RFC 5141-bis.
     class Type < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
       attribute :name, :string
       attribute :abbr, :string
       attribute :type_code, :string

data/lib/pubid/components/typed_stage.rb

@@ -7,6 +7,14 @@ module Pubid
     # Human render: typed-stage abbreviation with flavor-specific separator.
     # URN render: stage code (RFC 5141-bis: stage-XX.XX format handled by urn_generator).
     class TypedStage < Lutaml::Model::Serializable
+      include ::Pubid::SubsetMatch
+
+      # `original_abbr` records the input spelling ("Amd" or "AMD"), not the
+      # stage, so a subset match skips it.
+      def self.subset_ignored_attributes
+        %i[original_abbr]
+      end
+
       attribute :name, :string
       attribute :code, :string
       attribute :type_code, :string

data/lib/pubid/csa/CLAUDE.md

@@ -0,0 +1,41 @@
+# CSA flavor notes
+
+CSA convergence onto the cross-flavor identifier contract.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/csa/` or `spec/pubid/csa/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **CSA converged onto the cross-flavor contract (`root.number`, real container types, raise-never-nil)**: CSA was the last flavor outside the identifier contract, and the only one where `id.root.number` — the key `Relaton::Index::Type#candidates_by_number` sorts and bsearches on — **raised `NoMethodError`** rather than returning a value. A raise aborts a crawl; an empty key only degrades a search. Measured on `main` over the 829 parseable fixture ids: **0** had a non-empty `root.number`, **600** raised, only 228 survived `from_hash(to_hash)`, 13 raised on `to_mr_string` and 601 of 816 slugs carried characters outside `[a-z0-9._-]`. Four independent changes, plus three fixes they exposed.
+  **(1) `code` → `number`, and why it needed no type override.** `SingleIdentifier` declared `attribute :code, Components::Code` and never set the `number` it inherits; the fix **deletes the duplicate** rather than redeclaring anything, because `Pubid::Csa::Components::Code` **is** a bare alias of `Pubid::Components::Code` — exactly the type `::Pubid::Identifier` already declares for `number`. That distinction is load-bearing: CSA's base **is** split across two files (`csa/identifier.rb` + `csa/single_identifier.rb`), the IEEE counter-shape in which a leaf can snapshot a half-built parent attribute table (the `number` determinism landmine), so a *redeclaration* here would have been unsafe where W3C's one-file base made it safe. There is nothing to resolve nondeterministically when you declare nothing. `code` is dropped with **no alias**; readers moved in `builder.rb`, `renderer.rb`, `urn_generator.rb`, `bundled.rb`, `combined.rb`. **The serialized shape is flat** — a `key_value` block on `SingleIdentifier` collapses the `Components::Code` attributes to bare scalars (`number: C22.2-286`, not `number: {value: C22.2-286}`), the ISO/ETSI/ITU pattern. That is a *serialization mapping*, not a retype: the runtime attribute stays a `Components::Code`, so the determinism landmine is still avoided. Two placement facts matter — a lutaml `key_value` block is **exhaustive** (an unmapped attribute is silently dropped, `_type` included, so every attribute must be listed), and the block sits on **`SingleIdentifier`**, which only the single-document types inherit; the containers descend from `Csa::Identifier` directly and keep the default shape for their nested `base`/`identifiers` (whose members still flatten, via lutaml's nested transform). `Cec` declares a **second** block for `cec_part`, which lutaml merges with the inherited one; its `no_number` converter reads through either a `:string` (SingleIdentifier) or a `Components::Code` (Cec), since Cec redeclares that attribute. `Identifiers::Cec#code` (a *method* synthesising `"#{cec_part.value}-#{no_number.value}"`) became `def number` — it shadows lutaml's generated reader, safe because `Cec` declares no `number` of its own (the ITU `itu/identifiers/base.rb` precedent), and lossless because `cec_part`/`no_number` are themselves serialized so `from_hash` re-synthesises the same value. Keys: `Standard` → `"B149.1"`, `Series` → `"Z240"`, `Cec` → `"C22.2-286"`.
+  **(2) The five containers became real identifiers.** `WrapperIdentifier`, `CompositeIdentifier`, `Bundled` and `Combined` descended from bare `Lutaml::Model::Serializable` with a hand-written `def root; self; end`, and held their parent link in an **`attr_accessor`** — invisible to `to_hash`, `from_hash` **and** `#exclude` (which iterates `self.class.attributes`), so `CanadianAdopted#to_hash` was `{"reaffirmation" => "2023"}` and `CsaAdopted#to_hash` was `{}`. All four now `< Pubid::Csa::Identifier` with `attribute :base, ::Pubid::Identifier, polymorphic: true` — the **uniform `base` name**, so the inherited `#root` walks it and `exclude_from_nested` reaches inside; `wrapped_identifier` is gone with **no alias**. The type must be the **cross-flavor** `::Pubid::Identifier`, because `CsaAdopted` wraps ISO/IEC/CISPR ids and `polymorphic: true` widens only to *subclasses* (the `Ieee::Identifiers::AdoptedStandard` precedent); `Bundled#base`/`#bundled_with` were widened for the same reason, since a bundle's base is routinely a `Cec`, which is not a `Standard`. **`Combined` collapsed its `first`/`second`/`third` triple into one `identifiers` collection** (the IEC `ConsolidatedIdentifier` shape) — the triple was an observable hash shape hard-capped at three, and there is no published CSA index to migrate, so it was free to move; `#root` walks `identifiers.first`. All nine `polymorphic_name`s derive correctly and distinctly (`pubid:csa:canadian-adopted`, …), so **no explicit override is needed** — verify against `Pubid::Csa::Identifier.polymorphic_type_map` before adding one. The duplicated `to_mr_string`/`to_slug` on the two container base classes were deleted; the containers inherit `Csa::Identifier`'s, which also ended 13 `NoMethodError`s on `Combined`/`Bundled`. **`Identifiers::Base` stays a real intermediate class** (`< SingleIdentifier`), so CSA remains Category B in `identifier_hierarchy_spec.rb` — the containers attach to `Csa::Identifier` and deliberately bypass it.
+  **(3) The MR slug is charset-filtered, not escape-listed.** `to_mr_string` keeps its three *semantic* mappings (` ` → `.`, `:` → `.`, `/` → `-`, which carry CSA's segment structure) and then neutralises everything else by charset (`gsub(/[^a-z0-9._-]+/, "-")`, trimming leading/trailing separators) — the BIPM `mr_slug` precedent. Real CSA references carry `(`, `)`, `,`, `&` and `+`, all of which the old `tr` chain let through into what `to_slug` hands a filesystem. CSA keeps its whole-string `to_mr_string` override rather than moving to the `Renderers::MrString` hooks, because CSA identity lives in a dozen shape-specific attributes those seven hooks cannot see and `to_s` already round-trips losslessly. Still 0 collisions.
+  **(4) `parse` raises, never returns `nil`.** CSA and `api` were the only two flavors whose `parse` could return `nil` (measured across all 44 registered flavors; 28 raise a bare `RuntimeError`, 15 `Parslet::ParseFailed`, `bsi` a bare `StandardError` — the gem still has no single designed failure type, which is a **live follow-up**). A nil surfaces in the caller as a `NoMethodError` far from the input that caused it. All eight `return nil` branches now raise `Parslet::ParseFailed`, via a `build!` helper for the two that returned whatever `Builder#build` gave them. The guards after a *recursive* `parse` are simply gone — the inner call raises now. Two internal nil signals are deliberately kept: `parse_external_standard` (it probes several flavors) is translated to a raise at its one call site, and the package base scan — which walks progressively longer prefixes and keeps the longest that parses — gets a private **`try_parse`** that rescues back to nil.
+  **Three fixes these exposed.** **(a)** The builder marked a prefix-less reference (`C22.1-15`) with `publisher_prefix = ""`, a sentinel the canonical `to_hash` **drops by design** (it strips empty and default-valued attributes) — so such an id came back from `from_hash` with a nil prefix and re-rendered as `CSA C22.1-15`. Replaced by `attribute :code_only, :boolean, default: -> { false }`, named for the RARE case per the ITU rule so it is dropped from every ordinary row, read through `Renderer#publisher_prefix_for` and `UrnGenerator#code_only?` (the URN keeps its **empty** publisher segment, so URNs stay byte-identical). **(b)** `builder.rb` carried three `rescue Pubid::Errors::ParseError` clauses — **that constant does not exist**, only `Pubid::UrnParser::Errors::ParseError` does, so those "try ISO, else IEC" fallbacks raised `NameError` instead of falling back. Same class as the IETF URN-parser bug already recorded in `lib/pubid/ietf/CLAUDE.md`. **(c)** **Known, deliberately untouched:** `spec/pubid/csa/fixtures_spec.rb`'s glob has one `..` too many (repo-root `fixtures/`), so the whole fixture round-trip spec silently iterates an empty file list and reports **0 examples** — the exact ITU defect, again. It is left alone here because fixing it forces a `rake "validation:classify[csa]"` run, and that generator rewrites *whole files*: correcting the one bucket this change invalidates (`pass/nil_class.txt`, whose 21 entries now raise instead of returning nil) mechanically drags in ~28 unrelated `fail` → `pass` corrections that have been stale since 2026-04-01. Keeping them out keeps this diff to the task. Consequence to know: `pass/nil_class.txt` still lists 21 ids as "nil class" that now raise — inert, because nothing reads it while the glob is broken, and because CSA (unlike calconnect/bipm/ogc/iana) has no spec asserting that `fail/` fixtures fail. (follow-up hand-off: csa-revive-fixture-net.)
+  **The containers also needed the wrapper-specific overrides, not just the parent link.** Making them identifiers wires up `to_hash`/`from_hash`/`#exclude`/`root.number` for free, but `#base_document` and `#drop_supplements` — the matching vocabulary relaton normalises with — then inherit the base's `return self`, i.e. they answer with the **wrapper**. That is a *silently* wrong answer where the pre-reparenting `NoMethodError` was at least loud, so all five define both: `WrapperIdentifier`/`CompositeIdentifier`/`Bundled` peel through `base`, `Combined` through `identifiers.first` (the `ConsolidatedIdentifier` shape). **Known gap, pre-existing and deliberately left open:** CSA defines no URN shape for a container — `UrnGenerator` reads `publisher_prefix`/`number` straight off the identifier, which a container does not carry, so `to_urn` raises `NoMethodError`. It raised the identical error from the identical place on `main` (verified: 600 of 829 ids, both before and after), so nothing regressed; closing it needs a per-type URN-shape decision, because a bare delegation to `base` would collide a Canadian adoption with the standard it adopts. Pinned by a `root_number_spec.rb` block so the gap stays visible. **`Cec#number` is deliberately NOT memoised**: `@number` is the very ivar lutaml uses for the inherited attribute, so caching there would discard a value assigned through the generated writer and go stale if `cec_part`/`no_number` were reassigned — and `number` is the index key.
+  **Verified**: `to_s` **byte-identical** for all 829 ids that parsed on `main` (replayed from a captured baseline input list, not from the regenerated fixtures) and `to_urn` identical for all 829; `root.number` non-empty and raise-free for every parsing id; `from_hash(to_hash)` round-trips for every one; MR 0 raises / 0 unsafe characters / 0 collisions. Locked by `spec/pubid/csa/root_number_spec.rb` (structural tripwire + per-type key table + whole-corpus sweep over `spec/fixtures/csa/**`, which is what actually exercises the fixtures while `fixtures_spec.rb`'s glob stays broken; only meaningful under the full `bundle exec rake`), plus new CSA container rows in `root_spec.rb`, `identifier_roundtrip_spec.rb` (which carried a **pending** case for exactly this, now un-pended), `uniform_identifier_handle_spec.rb` and `mr_string_spec.rb` — none of which could carry a CSA wrapper row before. **relaton note**: there is no `relaton-csa` gem and no `relaton-data-csa`, so nothing published needs migrating; that is precisely why the serialized shape was changed properly rather than patched. (hand-off: csa-root-number-and-wrapper-hierarchy.)
+
+- **All six CSA containers rendered plain under `to_s(annotated: true)`,
+  for two different reasons.** The five wrappers — `Bundled`,
+  `CanadianAdopted`, `Combined`, `CsaAdopted`, `Package` — compose their
+  own string, so they needed `annotate_plain_render`; but adding it alone
+  fixed none of them, because a wrapper carries no identity of its own and
+  the annotator was reading only the wrapper's attributes. The wrap plus
+  `Annotator#emit_tokens` walking `base`/`identifiers` is what closes them.
+
+  **`Cec` defines no `to_s` at all** and already reached the choke point
+  inside `render`. It printed plain because `CSA C22.2 NO. 286:23` stores
+  the joined `"C22.2-286"` in `number`, which appears nowhere in the output,
+  while the halves it does print sit in `cec_part` and `no_number`. It
+  overrides `annotation_tokens` to name those two plus `publisher_prefix`.
+
+  **`CsaAdopted` is the one to be careful with**: its `to_s` regex-rewrites
+  the string it gets from `base.to_s` (`:2015`→`:15`, `/Amd 1`→`/A1`). That
+  is safe only because it calls `base.to_s` with no options, so the base is
+  plain, and because the annotation wrap goes on the **outside**. Move the
+  wrap inward and those patterns would start matching inside `<span
+  class="year">2015</span>`.
+
+## `Csa::Identifier#exclude` resets the whole year-format cluster, not just `year`
+
+Moved from the root `CLAUDE.md`'s `#exclude` bullet (`metanorma__pubid__exclude-recursion-depth`), where it had grown that bullet past the 100,000-byte session-load budget `spec/pubid/flavor_notes_spec.rb` enforces.
+
+**CSA follows the same scalar-year pattern** (`Csa::Identifier#exclude`): its `year` is a plain `:string`, but unlike BIPM the year carries *format metadata* stored in sibling attributes (`year_format`, `year_prefix`, `original_year_4digit`, and `french` — the last set **only** from a `:F` year prefix, the French-edition form `CSA B149.1:F20`). A year-less parse leaves all of these nil/false, so the override must reset **every** year-derived attribute (not just `year`) after `super`, or `==` — and thus `matches?` — would still diverge (e.g. a bare `CSA B149.1` would fail to match the French edition `CSA B149.1:F20`). The `respond_to?(:year=)` guard skips the adoption wrappers (`CanadianAdopted`/`CsaAdopted`), which delegate year to a nested inner id and lack a `year` accessor — those are handled by the base recursion.

data/lib/pubid/csa/builder.rb

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

data/lib/pubid/csa/identifier.rb

@@ -218,7 +218,8 @@ module Pubid
         # Detect CSA adoption of international standards
         # Examples: CSA ISO/IEC TR 12785-3:15, CSA CISPR 16-1-1:18, CSA IEC 60601-1:08
         #          CSA CEI/IEC 61000-4-28-01 (bilingual)
-        if input.match?(/^CSA (ISO\/IEC|CEI\/IEC|CISPR|IEC|CEI|ISO)\s/)
+        #          CSA IWA 18:17 (the catalogue also drops the ISO keyword)
+        if input.match?(/^CSA (ISO\/IEC|CEI\/IEC|CISPR|IEC|CEI|ISO|IWA)\s/)
           # This is CSA adoption of international standard
           # Extract the wrapped standard portion
           wrapped_input = input.sub(/^CSA\s+/, "")
@@ -495,6 +496,17 @@ module Pubid
           end
         end
 
+        # The catalogue also prints the IWA designation without the ISO
+        # keyword ("CAN/CSA-IWA 18:17" beside "CAN/CSA-ISO IWA 18:17");
+        # the ISO parser wants the ISO/ prefix.
+        if input.match?(/^IWA\s/)
+          begin
+            return Pubid::Iso.parse(input.sub(/^IWA\s/, "ISO/IWA "))
+          rescue StandardError
+            return nil
+          end
+        end
+
         # Try CISPR (uses IEC parser)
         if input.match?(/^CISPR\s/)
           begin