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

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

@@ -253,7 +253,7 @@ module Pubid
 
         # Code
         if parsed_hash[:code]
-          series.number = Components::Code.new(value: parsed_hash[:code].to_s)
+          series.number = parsed_hash[:code].to_s
         end
 
         # Year format and year
@@ -520,13 +520,13 @@ module Pubid
           # Pattern: "C22.1-15" should become code="C22.1", year="2015"
           if !data[:year] && code_value =~ /^(.+)-(\d{2})$/
             # Split code and year
-            identifier.number = Components::Code.new(value: $1)
+            identifier.number = $1
             # Convert 2-digit year to 4-digit
             year_2digit = $2
             identifier.year = "20#{year_2digit}"
             identifier.year_format = "dash"
           else
-            identifier.number = Components::Code.new(value: code_value)
+            identifier.number = code_value
           end
         end
 
@@ -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

data/lib/pubid/csa/identifiers/bundled.rb

@@ -47,7 +47,7 @@ module Pubid
                              end
                            end
             base_str = (needs_space ? "#{prefix} " : prefix) +
-              base.number.value.to_s + # Normalized code (e.g. "C22.2-1")
+              base.number.to_s + # Normalized code (e.g. "C22.2-1")
               ":#{year_display}"
             parts = [base_str]
           else
@@ -60,7 +60,7 @@ module Pubid
             bundled_with.each do |bundled|
               # For Cec identifiers, use normalized code format
               if bundled.is_a?(Cec)
-                bundled_part = bundled.number.value.to_s # e.g. "C22.2-2"
+                bundled_part = bundled.number.to_s # e.g. "C22.2-2"
                 if bundled.year
                   # Use dash if year_format is dash, otherwise colon
                   separator = bundled.year_format == "dash" ? "-" : ":"

data/lib/pubid/csa/identifiers/cec.rb

@@ -58,7 +58,7 @@ module Pubid
         def number
           return nil unless cec_part && no_number
 
-          Components::Code.new(value: "#{cec_part.value}-#{no_number.value}")
+          "#{cec_part.value}-#{no_number.value}"
         end
       end
     end

data/lib/pubid/csa/renderer.rb

@@ -115,7 +115,7 @@ module Pubid
 
         # Reaffirmation - preserve original format and determine spacing
         if id.reaffirmation && !id.reaffirmation.to_s.empty?
-          result += render_reaffirmation(id)
+          result += render_reaffirmation(id, year_prints_4digit: id.original_year_4digit == true)
         end
 
         # Package (already has leading space from parser)
@@ -225,11 +225,13 @@ module Pubid
 
       private
 
-      # Reaffirmation rendering helper - shared across Base, Cec, and Series
-      def render_reaffirmation(id)
-        # Check if year was originally 2-digit (original_year_4digit flag)
-        year_was_2digit = !id.original_year_4digit
-
+      # Reaffirmation rendering helper - shared across Base, Cec, and Series.
+      # The spacing follows the PRINTED year, not the parsed spelling: a
+      # 4-digit printed year glues ("C108.1.2-M1981(R2013)"), a 2-digit
+      # printed year takes a space ("C22.2 NO. 125-M84 (R2004)") — even
+      # when the input spelled the year 4-digit, since the CEC render
+      # always displays 2 digits.
+      def render_reaffirmation(id, year_prints_4digit: false)
         # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
         reaffirmation_was_4digit = id.original_reaffirmation_4digit
 
@@ -245,13 +247,11 @@ module Pubid
                               id.reaffirmation.to_s
                             end
 
-        # Determine spacing based on original formats
-        if year_was_2digit && reaffirmation_was_4digit
-          # Year was 2-digit, reaffirmation was 4-digit → add space
-          " (R#{reaffirmation_str})"
-        else
-          # Both 2-digit, both 4-digit, or other cases → no space
+        # Determine spacing based on the printed year
+        if year_prints_4digit || !reaffirmation_was_4digit
           "(R#{reaffirmation_str})"
+        else
+          " (R#{reaffirmation_str})"
         end
       end
 

data/lib/pubid/csa/single_identifier.rb

@@ -33,6 +33,23 @@ module Pubid
       attribute :package, :string         # Package portion (Code, Handbook, etc.)
       attribute :publisher_prefix, :string # Original prefix: "CAN/CSA-", "CSA", "CAN3-"
 
+      # Format flags that describe a value, keyed by that value. When the
+      # reference omits the value, a subset match skips its flags too: a bare
+      # `CSA C22.2 NO. 125` has `original_year_4digit` at its default `false`,
+      # which would otherwise refuse `CSA C22.2 NO. 125-M1984`.
+      SUBSET_FORMAT_FLAGS = {
+        year: %i[year_format year_prefix original_year_4digit french],
+        reaffirmation: %i[original_reaffirmation_4digit],
+      }.freeze
+
+      def subset_attribute_match?(name, mine, theirs)
+        return true if SUBSET_FORMAT_FLAGS.any? do |value, flags|
+          public_send(value).nil? && flags.include?(name)
+        end
+
+        super
+      end
+
       # True when the reference printed no publisher at all ("C22.1-15"), so
       # rendering must not supply the default "CSA".
       #
@@ -86,7 +103,7 @@ module Pubid
       end
 
       def number_from_kv(model, value)
-        model.number = Components::Code.new(value: value.to_s)
+        model.number = value.to_s
       end
 
       # `no_number` is a plain :string here but a Components::Code on Cec, so

data/lib/pubid/csa/urn_generator.rb

@@ -19,7 +19,7 @@ module Pubid
       def urn_number
         return nil unless identifier.number
 
-        identifier.number.render(context: URN_CONTEXT)
+        identifier.number.to_s
       end
 
       def urn_no_number

data/lib/pubid/doi/builder.rb

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

data/lib/pubid/easc/builder.rb

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

data/lib/pubid/ecma/CLAUDE.md

@@ -0,0 +1,28 @@
+# ECMA flavor notes
+
+ECMA edition and volume in the printed identifier, and the index key.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/ecma/` or `spec/pubid/ecma/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **ECMA edition and volume — the one flavor whose `to_s` deliberately renders MORE than the document number**: `Relaton::Index::Type#add_or_update` keys on a **bare** `id.to_s` and cannot pass render options, so the default rendering **is** the index key. ECMA's renderer used to say outright that "the edition is never rendered", and 740 of the 804 published `relaton-data-ecma` rows carry one — so all 804 rows collapsed onto **421** keys and **383 were dropped on every crawl, silently** (`ECMA-74` 22 rows to 1, `ECMA-262` 18 to 1). `edition` and `volume` are therefore rendered **by default**, with `to_s(with_edition: false, with_volume: false)` as the opt-out — the inverse of pubid's usual opt-in, and per-flavor divergence in exactly the way 3GPP (`with_publisher: false`) and W3C (`true`) already diverge. **`volume` is a new `attribute :volume, :string`** (relaton's `:vol:`), needed by exactly four rows: ECMA-269 ed3 vol1-4 share one docidentifier **and one title**, so the volume is the only thing separating those four index rows — it is an index discriminator, not something the document prints about itself. Both are plain `:string`s, so `#exclude`/`#matches?` already treat them as wildcards with no override (`ECMA-269` matches every edition under `ignore: %i[edition volume]`); ECMA's `partial_ref_spec.rb` entry moved from `omits: []` to `%i[edition volume]`.
+  **Grammar (`lib/pubid/ecma/parser.rb`)**: ` ed<N>` (dotted — `ed5.1` is real, ECMA-402) and ` vol<N>` attach as two independent `.maybe`s **after** the `tr | mem | standard` alternation, so a technical report and a memento carry them exactly as a standard does. The `standard` branch also gained a **space separator** (`ECMA 6`), which is a **NORMALIZING parse** — it renders back as `ECMA-6`, so it lives in `spec/pubid/ecma/edition_volume_spec.rb` and must **never** enter the byte-exact `pass` fixtures (the BIPM `CIPM/2005-06(REV)` precedent). **Two PEG facts are load-bearing and easy to lose.** (1) `standard` cannot shadow ` TR/`/` MEM/` because after the space it demands a **digit** — verified by inverting the alternation order, which still parses both correctly. Keeping `tr | mem` first is belt-and-braces; the **disjoint first character** is the real invariant. (2) Appending a sequence moved the alternation **out of tail position**, so Parslet no longer threads `consume_all` into it and **will not backtrack into an alternative that already succeeded** (`rule(:alt) { str("ab") | str("a") }; rule(:root) { alt >> str("bc") }` fails on `"abc"`). A future branch matching a proper prefix of another branch's input would now fail the whole parse where before it was rescued. `maybe` is `repeat(0,1)` and does not backtrack either, so a marker without its number (` ed`, ` ed5.`, ` vol`) fails atomically and then fails `consume_all` — which is what rejects `ECMA-6 ed` and pins the canonical suffix order (`ECMA-6 vol1 ed3` is rejected).
+  **Render-option threading — `:with_volume` rides the `:trademark` route, deliberately.** `Pubid::Identifier#render` `except`s a flag from the rendering context and `slice`s it to the renderer; `:with_edition` was already in both, and `:trademark` is the precedent for an **IEEE-only** flag carried the same way. So `:with_volume` was added to those two lines and **`build_rendering_context`'s signature was left alone** — widening it would touch `Pubid::Iso::SingleIdentifier`'s strict override. The payoff is that **ECMA's `to_s` needed no change at all** and the renderer owns the defaults: no second transient ivar beside the pre-existing `@with_publisher`, so rendering stays stateless and reentrant. Residual blast radius, accepted: passing `with_volume:` to a *non*-ECMA identifier now reaches that flavor's renderer instead of dying in the context builder — `Renderers::HumanReadable` absorbs unknown opts by design, while ISO's three strict renderers (`DirectivesRenderer`/`IwaRenderer`/`SupplementRenderer`) raise, which they did before too.
+  **All three identity surfaces, and the two defects found by measuring them.** Per the project rule, edition and volume reach `to_s`, `to_urn` **and** `to_mr_string`. **URN**: labelled segments after the existing `part-<n>` (`urn:ecma:269:ed-3:vol-2`), purely additive — `UrnParser` probes for a labelled prefix (a `shift_labelled` helper using `delete_prefix`, not `sub`), so a URN minted before the segments existed still reads back. The **dot of a decimal edition is KEPT** (`urn:ecma:402:ed-5.1`): `.` is `unreserved` in RFC 8141 and the URN has an inverse, so it must be lossless. **MR**: ECMA defined **no** `mr_*` hooks, so (a) the base `mr_edition` (`edition&.number`) **raised `NoMethodError` on all 740 edition-carrying rows** — the BIPM/ASTM/ASHRAE crash again — and (b) `mr_publisher` was nil (the publisher is the `PUBLISHER` constant, not the inherited attribute) and `mr_type` was nil (the Builder picks a class, it never sets a `typed_stage`), so **`ECMA-101` and `ECMA TR/101` both slugged to `"101"`** and one output filename overwrote the other. Four hooks fix it, sanitising **by charset** (`gsub(/[^a-z0-9]+/, "-")`, the BIPM `mr_slug` precedent) rather than by an escape list. **The MR is deliberately lossy where the URN is not** (`ed5-1` vs `ed-5.1`): `Renderers::MrString` joins **segments** with `.`, so a dot inside one breaks the documented structure, and nothing parses an ECMA MR back (`Parsers::MrString::FLAVOR_MAP` has no ECMA entry). Say so in the comment rather than leaving the asymmetry looking accidental.
+  **New shared `mr_volume` slot.** `Renderers::MrString#render_flat` had no volume segment, so it gained one plus a **literal-nil** `mr_volume` hook on `Pubid::Identifier` — literally nil, **not** `volume&.to_s`, because `Pubid::Nist::Identifiers::Base` declares its own `volume` attribute with different MR semantics and a generic reader would silently move NIST's slug. Inert by construction (no flavor defined `mr_volume`, there is no `method_missing` in `lib/pubid`, and NIST overrides `to_mr_string` wholesale), and verified rather than assumed: a `main` baseline replay of `to_mr_string` over all **98,217** identifiers in `spec/fixtures/*/identifiers/pass/*.txt` is **byte-identical**. `render_flat` was rewritten around a frozen `SEGMENTS` list of hook names while it was open, which also cleared a pre-existing ABC offence.
+  **The corpus is the gate.** `spec/fixtures/ecma/identifiers/pass/index_corpus.txt` is the complete published index (804 rows) rendered as `"<:id:>[ ed<:ed:>][ vol<:vol:>]"`, generated from `relaton-data-ecma/index-v1.yaml`; `spec/pubid/ecma/corpus_spec.rb` asserts over all of it that every row parses and renders byte-exactly, that `to_s`/`to_urn`/`to_mr_string` each give **804 distinct** keys, that every slug is filename-safe, that the URN and the hash both round-trip, that `from_hash(to_hash) == id` (stronger than hash equality — `#matches?` is built on `==`), and that `root.number` is non-empty. **ECMA has no `identifiers/full/` corpus**, so `rake "validation:classify[ecma]"` cannot run and cannot clobber these files — its fixtures are hand-maintained, unlike every generated flavor. Note ECMA's `fixtures_spec.rb` glob is **correct** (two `..`, lowercase dir) and is not one of the ten dead ones. **Two existing specs asserted the inverted contract** and had to flip (`serialization_spec.rb`'s "omits edition from the printed string"), so a green suite before the code change was the failure signal, not the success one. **relaton note**: this unblocks `relaton__relaton__ecma-consume-index-v2`; `relaton-data-ecma`'s `index-v1` is string-keyed and no ECMA pubid index is published yet, so nothing needs migrating — but the crawl must run after this lands, or the rows key on the collapsed form again. (hand-off: ecma-edition-and-volume.)
+
+## 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:)`.
+
+- **`part` is strict** (`lib/pubid/ecma/identifier.rb`). `ECMA-418` is the
+  whole document, not part 1 of it, so `ECMA-418 === ECMA-418-1 ed1` is
+  false. relaton measured 5 spurious part rows for that one reference
+  before the declaration existed. `edition` and `volume` stay wildcards —
+  an omitted edition really does mean "any edition", which is why
+  `partial_ref_spec.rb` lists them under `omits`.

data/lib/pubid/ecma/builder.rb

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

data/lib/pubid/ecma/identifier.rb

@@ -20,6 +20,13 @@ module Pubid
       # is only present for standards that split into parts (e.g. ECMA-418-1).
       attribute :number, :string
       attribute :part, :string
+
+      # A nil `part` means the document has no part, not "any part":
+      # `ECMA-418` is not `ECMA-418-1`. relaton measured 5 spurious part rows
+      # for that one reference. A caller that wants every part of a document
+      # sets `all_parts` on the reference.
+      subset_strict :part
+
       # Edition is relaton's `:ed:` (the index stores {:id, :ed, :vol} and the
       # YAML has edition.content). It is part of the printed identifier: the
       # relaton index keys on a bare `to_s`, so without it all 22 editions of

data/lib/pubid/etsi/CLAUDE.md

@@ -0,0 +1,34 @@
+# ETSI flavor notes
+
+ETSI index key, part exclusion and MR slug.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/etsi/` or `spec/pubid/etsi/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+## From the root note "ETSI and OIML index key (`root.number`): the `code` component became flat leaf columns"
+
+**(3) `exclude(:part)` needed an override.** With `parts` a real collection attribute the base `#exclude` reaches it and nils it — but a part-less reference parses with `parts` defaulting to `[]`, so `nil != []` would break `==` and therefore `#matches?` against exactly the reference the exclusion exists to match. `Pubid::Etsi::Identifier#exclude` resets it to `[]` after `super` (the "reset the WHOLE cluster" rule from CSA's year and IEEE's year/month/day); this also covers supplements, since the base recurses into the nested `base` through `exclude_from_nested`. The old `exclude_from_nested` `Components::Code` special-case was deleted as dead. **(4) The ETSI MR slug was rewritten, and this is the loud part of the change.** ETSI defined no `mr_*` hooks, and the base ones read the inherited `number`/`part`/`typed_stage`/`edition` — all nil for ETSI — so **every** ETSI slug was `etsi.<date>`: **454 distinct slugs for 24,724 documents**, 794 of them sharing `etsi.2018-07`, and `to_slug` is what consumers use as an output **filename**. `EtsiStandard` now supplies `mr_number_with_part` (number + `parts`), `mr_type` (the ETSI type token) and `mr_edition` (the `version`) — all four fields ETSI's `==` compares, per the rule that an identity-bearing marker must reach **every** identity surface, not just `==`. `SupplementIdentifier` gained `mr_supplement_suffix` so the shared renderer **recurses into `base`** instead of slugging the supplement flat off its own ordinal (which made every `/C1` corrigendum of one month share `etsi.1.<date>`) — the ITU `AnnexOfRecommendation` precedent. A shared **`mr_sanitize`** filters **by charset** (`[^a-z0-9-]` → `-`), not by an enumerated escape list: an ETSI number legitimately contains a **space** (`300 175`, `GSM 02.01`), which is outside the `[a-z0-9.-]` charset `Renderers::MrString` documents, and a dot inside a segment would break that renderer's `.`-joined segment structure (the BIPM `bipm.si-brochure.9e-v3-01.e` precedent). Result: **24,724 distinct slugs for 24,724 ids, 0 collisions, 0 unsafe characters.** OIML's MR is **unchanged** — it already had its own `mr_number_with_part` reading through `code`, which the derived reader keeps working.
+
+## 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:)`.
+
+- **`parts` is strict**, on the leaf `EtsiStandard` and on
+  `Etsi::Components::Code`. A stated part list is not a prefix, so
+  `ETSI TS 129 198-4 === ETSI TS 129 198-4-5` is false. This was the
+  largest case relaton measured: over 10,595 bare type+code queries the
+  matched set changed for 158 and the `best_match` winner for 122, and
+  `ETSI TS 129 198-4` resolved to `-4-5`.
+- The declaration sits **on the leaf**, beside the flat columns and for the
+  same reason — `EtsiStandard` owns `number`/`minor`/`parts`, while the
+  shared `Pubid::Etsi::Identifier` is also `SupplementIdentifier`'s parent.
+  `Etsi::Components::Code` carries the same declaration although `===`
+  cannot reach it today (`#code` is a derived reader, not an attribute), so
+  the two shapes cannot drift.
+- `SUBSET_PAIRS["etsi"]` in `spec/pubid/subset_match_spec.rb` moved from
+  `ETSI EN 300 175` to `ETSI EN 300 175-1`: the reference now states its
+  part, and the version and the date are what it omits.

data/lib/pubid/etsi/builder.rb

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

data/lib/pubid/etsi/components/code.rb

@@ -14,10 +14,16 @@ module Pubid
       # Stays independent of Pubid::Components::Code because ETSI uses
       # +minor+ (a flavor-specific sub-number) plus +parts+.
       class Code < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :number, :string # Main number
         attribute :minor, :string # Optional minor part
         attribute :parts, :string, collection: true, default: [] # Parts array
 
+        # Mirrors the flat `parts` column of EtsiStandard, which owns the
+        # identity; this component is derived from it by `#code`.
+        subset_strict :parts
+
         # Render code with space for minor and dash-separated parts
         def to_s
           result = number.to_s

data/lib/pubid/etsi/components/version.rb

@@ -8,6 +8,8 @@ module Pubid
       # Represents an ETSI version string
       # Format: V1.2.3, V2.0.0, or ed.1
       class Version < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :version, :string # e.g., "1.1.1", "2.0.0", "1"
         attribute :is_edition, :boolean, default: -> {
           false

data/lib/pubid/etsi/identifiers/etsi_standard.rb

@@ -44,6 +44,13 @@ module Pubid
         attribute :minor, :string
         attribute :parts, :string, collection: true, default: -> { [] }
 
+        # The reference always states its parts. An empty list means the
+        # document has no part, and a stated list is not a prefix:
+        # `ETSI TS 129 198-4` is not `ETSI TS 129 198-4-5`. Over 10,595 bare
+        # ETSI queries relaton measured 122 changed `best_match` winners
+        # without this. A caller that wants every part sets `all_parts`.
+        subset_strict :parts
+
         # Compact serialization (mirrors ISO/JCGM/OIML): the code fields are
         # bare scalars (`number`, a `parts` array and, rarely, a `minor`);
         # Version flattens to a scalar `version` string with an `is_edition`

data/lib/pubid/evs/CLAUDE.md

@@ -0,0 +1,58 @@
+# EVS flavor notes
+
+- **The wrapped document is `base`, the uniform parent accessor**: EVS shipped
+  with `adopted_identifier`, the name the rest of the codebase already retired.
+  The rename covers the Ruby attribute **and** the serialization key, so an EVS
+  row now reads `{"_type" => "pubid:evs:national-adoption", "base" => {…}}`.
+  **The name is load-bearing, not cosmetic.** `Pubid::Identifier#root` walks
+  `base`, so every EVS identifier used to be its own root with a nil `number`,
+  and relaton keyed all of them under the empty string `""` — the index-key
+  defect this repository records for wrappers in many other flavors.
+  `root.number` is now the origin standard's number (`"9001"` for
+  `EVS-EN ISO 9001:2015/A1:2024`, through two wrapper layers, because `#root`
+  recurses). `Renderers::Annotator#emit_tokens` also walks `base`, so
+  `to_s(annotated: true)` now annotates the wrapped document instead of
+  returning a bare string.
+  **What moved and what did not**: `to_s`, `to_urn` and the identifier classes
+  are unchanged; `to_hash` changes one key name, and `to_s(annotated: true)`
+  gains spans. EVS has no published `relaton-data-evs` index, so nothing stored
+  needs a migration — but the **pubid-testsuite corpus rows carry the old key**
+  and report `canonical hash` for all 10 EVS cases until the flavor is
+  re-exported. `to_mr_string` is still `""` for EVS (pre-existing: EVS supplies
+  no `mr_*` hooks).
+  Locked by the "uniform parent accessor" block in `spec/pubid/evs/evs_spec.rb`.
+
+- **`from_hash` raised on every EVS hash — a raw default, not load order
+  (pubid#383)**: `Pubid::Evs::Identifier.from_hash(id.to_hash)` raised
+  `Lutaml::Model::InvalidFormatError` (`undefined method 'key?' for an instance
+  of Symbol`). The cause was one line in
+  `lib/pubid/evs/identifiers/national_adoption.rb`:
+  `attribute :type, Components::Type, default: -> { self.class.type[:key] }`.
+  The default was the Symbol `:evs_en`, not a `Components::Type`. The canonical
+  `to_hash` drops a default-valued attribute, so no row carries `type`. On
+  `from_hash`, lutaml finds no `type` key, resolves the default, and casts it
+  into the component through `Components::Type.from_hash(:evs_en)`, which
+  raises. The nested cross-flavor wrapped identifier was never the problem:
+  it deserializes alone through `Pubid.from_hash`.
+  **The fix landed on `main` in `ea6cab30`**, which gives EVS and all six IDF
+  classes a `self.class.default_type` class method returning
+  `Components::Type.new(abbr: type[:short])` — the cen_cenelec shape. Nothing in
+  EVS reads `type` (builder, renderer, URN generator and URN parser), and `type`
+  is still absent from the hash, so nothing rendered or serialized moved.
+  **The issue thread called it process-shape dependent. It is not.** It raises
+  in every load order tried (plain `require`, `Pubid.eager_load_flavors!`, CEN
+  loaded first, BSI loaded first), and all 10 corpus cases raised on `main`,
+  not only the one row the testsuite ledger names. The exporter looked clean
+  because `Conformance::Generator#round_trips?` rescues `StandardError` and
+  returns `false`, so a raise there never reached the report.
+  **Do not read `self.class` inside the default lambda body.** lutaml calls the
+  lambda with `instance_exec` when it has an instance, but calls it plainly
+  (`options[:default].call`) when it has none, and `self.class` is then `Class`.
+  A `default_type` class method keeps that resolution in one place.
+  **Two specs guard the bug class, and they are complementary**:
+  `spec/pubid/evs/from_hash_spec.rb` greps `lib/` for the one raw spelling, so a
+  copy of that exact line fails fast; `spec/pubid/component_attribute_default_spec.rb`
+  **evaluates** every component-typed default of every identifier class of every
+  flavor, so a raw default of any spelling or component type fails, whatever
+  flavor introduces it. Its `PENDING_RAW_DEFAULTS` table is empty today; an
+  entry that starts to pass turns red, which is the signal to delete it.

data/lib/pubid/evs/builder.rb

@@ -17,10 +17,12 @@ module Pubid
         adopted = Pubid::CenCenelec::Builder.build(data[:adopted])
 
         Identifiers::NationalAdoption.new(
-          adopted_identifier: adopted,
+          base: adopted,
           separator: data[:evs_separator] || "-",
         )
       end
     end
   end
 end
+
+Pubid::Evs::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/evs/identifier.rb

@@ -3,16 +3,16 @@
 module Pubid
   module Evs
     # An EVS national adoption wraps a CEN identifier the same way BSI's
-    # AdoptedEuropeanNorm does — polymorphic `adopted_identifier` so the
+    # AdoptedEuropeanNorm does — polymorphic `base` so the
     # wrapped object stays a real Pubid::CenCenelec identifier.
     #
     # Examples:
-    #   "EVS-EN 18216:2026"           (adopted_identifier: EN 18216:2026)
-    #   "EVS-EN ISO 14001:2026"       (adopted_identifier: EN ISO 14001:2026)
-    #   "EVS-EN ISO/IEC 27017:2026"   (adopted_identifier: EN ISO/IEC 27017:2026)
-    #   "EVS-EN ISO 9001:2015/A1:2024" (adopted_identifier: EN ISO 9001:2015/A1:2024)
+    #   "EVS-EN 18216:2026"           (base: EN 18216:2026)
+    #   "EVS-EN ISO 14001:2026"       (base: EN ISO 14001:2026)
+    #   "EVS-EN ISO/IEC 27017:2026"   (base: EN ISO/IEC 27017:2026)
+    #   "EVS-EN ISO 9001:2015/A1:2024" (base: EN ISO 9001:2015/A1:2024)
     class Identifier < ::Pubid::Identifier
-      attribute :adopted_identifier, ::Pubid::Identifier, polymorphic: true
+      attribute :base, ::Pubid::Identifier, polymorphic: true
       # "-" or " " — preserves the printed separator ("EVS-EN" vs "EVS EN")
       attribute :separator, :string, default: -> { "-" }
 

data/lib/pubid/evs/identifiers/national_adoption.rb

@@ -6,10 +6,15 @@ module Pubid
       # The EVS national adoption of a European Standard.
       # Example: "EVS-EN 18216:2026"
       class NationalAdoption < ::Pubid::Evs::Identifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
+
+        def self.default_type
+          Components::Type.new(abbr: type[:short])
+        end
 
         def self.type
-          { key: :evs_en, title: "EVS National Adoption of a European Standard" }
+          { key: :evs_en, short: "EN",
+            title: "EVS National Adoption of a European Standard" }
         end
       end
     end

data/lib/pubid/evs/renderer.rb

@@ -23,7 +23,7 @@ module Pubid
       end
 
       def adopted
-        @id.adopted_identifier.to_s
+        @id.base.to_s
       end
     end
   end

data/lib/pubid/evs/urn_generator.rb

@@ -17,7 +17,7 @@ module Pubid
       EVS_NAMESPACE = "urn:evs:"
 
       def generate
-        adopted_urn = identifier.adopted_identifier.to_urn
+        adopted_urn = identifier.base.to_urn
         unless adopted_urn.start_with?(CEN_NAMESPACE)
           raise Errors::ParseError,
                 "expected adopted CEN URN, got #{adopted_urn.inspect}"

data/lib/pubid/evs/urn_parser.rb

@@ -56,7 +56,7 @@ module Pubid
 
         adopted = Pubid::CenCenelec.parse(text)
         ::Pubid::Evs::Identifiers::NationalAdoption.new(
-          adopted_identifier: adopted,
+          base: adopted,
         )
       end