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

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".
       #

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

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

data/lib/pubid/gb/CLAUDE.md

@@ -0,0 +1,140 @@
+# GB (Chinese Standard) flavor notes
+
+`Pubid::Gb` covers national (`GB`), confidential national (`GBn`),
+sector/industry (`JB`, `HB`, `NY`, …) and social-group (`T/{ORG}`) Chinese
+standards. The mandate category follows a slash: `T` (recommended), `Z`
+(guideline), or nothing (mandatory).
+
+## A flavor `key_value` block REPLACES the base maps — list every attribute
+
+`Pubid::Gb::Identifier` declared its own `key_value` block and mapped
+`publisher_code`, `mandate`, `number`, `part` and `all_parts` — but not
+`date`. lutaml does not merge such a block with the maps of
+`::Pubid::Identifier`; it replaces them. So `to_hash` silently dropped the
+publication year of **every** dated GB identifier:
+
+```ruby
+id = Pubid::Gb::Identifier.parse("GB/T 20223-2006")
+id.to_s                                            # => "GB/T 20223-2006"
+id.year                                            # => "2006"
+id.to_hash                                         # no year at all
+Pubid::Gb::Identifier.from_hash(id.to_hash).to_s   # => "GB/T 20223"
+```
+
+The year survived `to_s`, `exclude` and `matches?`, so nothing in the flavor's
+own behaviour looked wrong. Only `from_hash(to_hash) == parse` saw it — the
+silent failure mode this repository records elsewhere: `#matches?` is
+`exclude(*ignore) == other.exclude(*ignore)`, so a parsed reference never
+matched a `from_hash`-ed index row, and the lookup returned nothing with no
+error. Two editions of one document (`GB/T 20223-2006` and `GB/T 20223-2014`)
+also collapsed onto one hash.
+
+The fix is one line — `map "date", to: :date` — because the shared flat-scalar
+rules do the rest: `flatten_scalar_components` (in `Identifier#to_hash`) writes
+a bare `"year" => "2006"` instead of a nested `date` component, and
+`inflate_scalar_components` reads it back. GB declares no `year` attribute, so
+the `date` → `year` rename applies.
+
+```ruby
+Pubid::Gb::Identifier.parse("GB/T 20223-2006").to_hash
+# => {"_type" => "pubid:gb:standard", "publisher_code" => "GB",
+#     "mandate" => "T", "number" => "20223", "year" => "2006"}
+```
+
+**Lesson for any flavor with its own `key_value` block**: an attribute absent
+from the block does not serialize. Assert `from_hash(id.to_hash) == id`, not
+only `to_s` and `to_hash` — the two shapes that were already correct here.
+
+GB publishes no `relaton-data-gb` index, so no re-crawl follows.
+
+## `GBn` — a lowercase letter inside the publisher token
+
+`GBn` is the confidential national series, and the only one of the 67 prefixes
+the relaton GB flavor carries that did not parse. The publisher rule accepted
+`[A-Z]{1,3}`, which consumed `GB` and then stopped at the `n`.
+
+A PEG takes the first branch that matches and does not backtrack into the
+alternatives, so the `str("GBn")` branch comes **before** the uppercase-only
+branch in `rule(:publisher_code)`. `GBn`, `GBn/T` and `GBn/Z` now parse, and
+`GBn GBn/T GBn/Z` are in `PREFIXES`, so `Pubid.parse` routes them.
+
+All 67 relaton prefixes now round-trip a dated identifier.
+
+## Decision: the em dash normalizes to an ASCII hyphen
+
+Chinese portals print an em dash before the year (`T/ZS 0467—2023`). The parser
+accepts both spellings and the renderer prints an ASCII hyphen:
+
+```ruby
+Pubid::Gb::Identifier.parse("T/ZS 0467—2023").to_s   # => "T/ZS 0467-2023"
+```
+
+This is deliberate, not a defect. The two spellings give **equal** identifiers,
+so a reference in either form matches the document. The alternative — a stored
+separator attribute, the CIE `date_separator` shape — would make the two
+spellings unequal and would need an `exclude` override. The relaton fixture
+`spec/gb/fixtures/tgzaepi_001_2018.xml` records the em-dash form and is the one
+place that must follow this decision.
+
+## The series code lives in the inherited `publisher`
+
+`GB`, `JB`, `GBn` and `T/GZAEPI` are stored in the `publisher` attribute
+inherited from `::Pubid::Identifier`, a `Components::Publisher`. The flavor had
+its own `publisher_code` string beside it while the inherited attribute stayed
+nil, so two attributes described one value and the shared code that reads
+`publisher` saw nothing.
+
+The component serializes as a bare scalar, because the class adds itself to the
+flat-scalar table — the CEN/CENELEC precedent, and for GB's own classes only:
+
+```ruby
+Pubid::Gb::Identifier.flat_scalar_components   # => {..., publisher: "publisher"}
+Pubid::Gb::Identifier.flat_scalar_fields       # => {..., publisher: :body}
+```
+
+```ruby
+{"_type" => "pubid:gb:standard", "publisher" => "GB",
+ "mandate" => "T", "number" => "20223", "year" => "2006"}
+```
+
+**The URN gained the series, which repairs a collision.** `GB 20223-2006` and
+`GBn 20223-2006` are two documents and shared `urn:gb:20223:2006`; they now
+give `urn:gb:gb:20223:2006` and `urn:gb:gbn:20223:2006`. The shared URN
+generator lowercases the body on its own. The MR slug follows (`gb.20223.2006`,
+`gbn.20223.2006`) and sanitizes the slash of a social-group code by itself
+(`T/GZAEPI` → `t-gzaepi.001.2018`), so GB does not join the IEEE slash ledger.
+Annotated rendering gained a `publisher` span for free.
+
+**Note the parse-tree key keeps its name.** `rule(:publisher_code)` in the
+parser still captures `:publisher_code`; parse-tree keys and attribute names
+are different namespaces (the ASHRAE landmine). Only the attribute moved.
+
+## Known gaps
+
+`spec/pubid/gb/fixtures_spec.rb` now reads `spec/fixtures/gb/`, which nothing
+read before (the `ten-dead-fixture-specs` class). It carries a tripwire example
+asserting both globs are non-empty, because a wrong glob reports 0 examples
+instead of a failure. GB has no `identifiers/full/identifiers.txt`, so the
+fixtures are hand-written and `rake validation:classify[gb]` does not drive
+them; the reader accepts both the plain and the generated line shapes.
+
+The URN carries the series, the number and the year, but **not the mandate**:
+`GB 20223-2006` and `GB/T 20223-2006` both give `urn:gb:gb:20223:2006`, and
+their MR slugs are equal too. The mandatory and the recommended standard are
+two documents, so this is a real collision, narrower than the one the series
+repaired. There is also no `Pubid::Gb::UrnParser`, so a GB URN cannot be read
+back. Nothing consumes a GB URN today, so both are recorded, not fixed.
+
+## Not supported (deliberately)
+
+These forms do not parse. Each is outside what the relaton GB flavor supports
+today:
+
+| form | what it is |
+|---|---|
+| `DB11/T 123-2020`, `DB37 1234-2020` | local standards; a province code follows `DB` |
+| `Q/SY 123-2020` | enterprise standard |
+| `GB/T 1.1-2020/XG1-2021` | amendment sheet (修改单) |
+
+`PREFIXES` lists bare `DB`, `DB/T` and `DB/Z`, so the province-numbered form
+was intended but is not parsed.

data/lib/pubid/gb/builder.rb

@@ -17,14 +17,17 @@ module Pubid
       def build(data)
         code, mandate = split_mandate(data[:publisher_code].to_s)
 
-        Identifiers::Standard.new(
+        identifier = Identifiers::Standard.new(
           publisher: ::Pubid::Components::Publisher.new(body: code),
           mandate: mandate || data[:mandate]&.to_s,
           number: data[:number].to_s,
           part: data[:part]&.to_s,
           date: date_for(data[:year]),
-          all_parts: !data[:all_parts].to_s.empty?,
         )
+
+        # "(all parts)" names every part of the document, so it wraps the
+        # document, which holds no mark itself.
+        data[:all_parts].to_s.empty? ? identifier : identifier.to_all_parts
       end
 
       private
@@ -48,3 +51,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Gb::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/gb/identifier.rb

@@ -7,6 +7,11 @@ module Pubid
     # descend from this class, so a parsed GB id is always an instance of
     # Pubid::Gb::Identifier.
     class Identifier < ::Pubid::Identifier
+      # The all-parts identifier of this flavor.
+      def self.all_parts_class
+        Identifiers::AllParts
+      end
+
       # The issuing body code as printed — "GB", "JB", "GBn", "T/GZAEPI" —
       # lives in the `publisher` attribute inherited from ::Pubid::Identifier.
       # The flat-scalar hooks below serialize it as a bare string, and the
@@ -25,8 +30,6 @@ module Pubid
       # uses the dotted form (e.g. "5606.1" => number "5606", part "1").
       attribute :part, :string
 
-      # All-parts flag — true for "GB/T 5606 (all parts)" forms.
-      attribute :all_parts, :boolean, default: -> { false }
 
       # Polymorphic type map for lutaml key_value (de)serialization.
       GB_TYPE_MAP = {
@@ -44,7 +47,6 @@ module Pubid
         map "number", to: :number
         map "part", to: :part
         map "date", to: :date
-        map "all_parts", to: :all_parts, render_default: false
       end
 
       PUBLISHER = "CN"

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

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

data/lib/pubid/gb/identifiers.rb

@@ -3,6 +3,7 @@
 module Pubid
   module Gb
     module Identifiers
+      autoload :AllParts, "#{__dir__}/identifiers/all_parts"
       autoload :Standard, "#{__dir__}/identifiers/standard"
     end
   end

data/lib/pubid/gb/renderer.rb

@@ -13,7 +13,6 @@ module Pubid
     class Renderer < ::Pubid::Renderers::Base
       def render(**_opts)
         parts = [publisher_portion, " #{number_portion}"]
-        parts << " (all parts)" if @id.all_parts
         parts.join
       end
 

data/lib/pubid/gost/CLAUDE.md

@@ -0,0 +1,64 @@
+# GOST flavor notes
+
+Foreign-adoption routing: the slash-attached prefix boundary that let another
+flavor win the routing race.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/gost/` or `spec/pubid/gost/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+## Foreign-adoption routing must use a token-boundary prefix check, not a literal-space check
+
+`Gost::Builder#parse_foreign` (`lib/pubid/gost/builder.rb`) resolves the
+foreign standard a GOST document adopts (`"GOST 58904-2020/ISO/TR
+25901-1:2016"` → the adopted `"ISO/TR 25901-1:2016"`) by routing through
+`Pubid.prefix_flavors` first — the same "registered prefix, not load order"
+mechanism the earlier `gost-adoption-prefix-routing` fix introduced for
+`"GOST 1437-2024 (ASTM D129-18)"` — and falling back to an exhaustive,
+alphabetically-sorted try-every-flavor loop only when no registered prefix
+matches.
+
+`prefix_owner`'s boundary check used to require a **literal space** after the
+matched prefix (`raw.start_with?("#{p} ")`). That misses a form where the
+type token is attached to the publisher with a **slash** instead of a space —
+`"ISO/TR 25901-1:2016"`, `"ISO/TS 10303-1:2014"` — because the character
+after `"ISO"` is `/`, not a space. Those strings therefore matched no
+registered owner and fell through to the exhaustive fallback loop, racing
+every registered flavor's grammar alphabetically.
+
+**The race was real, not theoretical: `Pubid::Iec`'s own grammar also accepts
+a bare `"ISO/TR 25901-1:2016"`** (as its own identifier, not as a delegation
+to ISO), and renders it `"ISO TR 25901-1:2016"` — a space, IEC's own
+convention, not ISO's. `Pubid::Bsi` also accepts the string and correctly
+delegates to `Pubid::Iso::Identifiers::TechnicalReport`, and normally wins the
+race because `"bsi"` sorts alphabetically before `"iec"` — which is exactly
+why the wrong render (`GOST R 58904-2020/ISO TR 25901-1:2016` instead of
+`.../ISO/TR 25901-1:2016`) was rare and reproduced only intermittently, and
+only under full-suite load (hand-off
+`metanorma__pubid__gost-idt-order-dependent-render.md`; the hand-off chased
+GC/allocation timing and `RenderingContext` memoization as candidate causes —
+neither was it, and neither needed to be pinned down, since routing this
+deterministically by prefix removes the race regardless of what let `bsi`
+occasionally lose it).
+
+**Fix**: `prefix_owner` now uses the same token-boundary rule the top-level
+router already uses (`Pubid.prefix_match?` in `lib/pubid.rb` — a non-word
+character, not specifically a space, ends the prefix). That method used to be
+`@api private`; it is now public for exactly this reason — a second,
+hand-copied boundary check in `Gost::Builder` would be the same
+duplicated-logic-drifts-out-of-sync hazard this file documents elsewhere for
+other flavors (found in code review, not the first pass: the initial fix
+duplicated the regex locally instead of calling the shared method). **Do
+not** re-duplicate this boundary check in a flavor's own builder; call
+`::Pubid.prefix_match?(string, prefix)`.
+
+**Not affected**: a jointly-owned prefix (`"ISO/IEC"`, `"ISO/IEC TR"`) already
+falls through to the exhaustive fallback by design (`owners.one?` is false),
+and every owner renders it identically — verified for both the bare and the
+type-attached compound forms. Only the single-owner, slash-attached-type
+shape (`"ISO/TR"`, `"ISO/TS"`, and by the same rule `"IEC/TR"` etc.) was
+broken.
+
+Locked by `spec/pubid/gost/foreign_adoption_routing_spec.rb`, which includes
+a deterministic reproduction of the race (not a reliance on catching the rare
+full-suite failure): it temporarily `Registry.unregister(:bsi)`s the usual
+race winner and asserts routing still resolves to `Pubid::Iso` correctly —
+proving the fix is prefix routing, not a lucky alphabetical ordering.

data/lib/pubid/gost/builder.rb

@@ -166,7 +166,7 @@ module Pubid
       def prefix_owner(raw)
         index = ::Pubid.prefix_flavors
         match = index.keys
-                   .select { |p| raw.start_with?("#{p} ") || raw == p }
+                   .select { |p| ::Pubid.prefix_match?(raw, p) }
                    .max_by(&:length)
         return nil unless match
 
@@ -183,3 +183,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Gost::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/gost/identifier.rb

@@ -23,6 +23,11 @@ module Pubid
       attribute :number,      :string
       attribute :year,        :string
 
+      # A nil `copublisher` means GOST alone: `GOST R 27001` is not
+      # `GOST R ISO/IEC 27001`, which is an adoption of another body's
+      # document.
+      subset_strict :copublisher
+
       GOST_TYPE_MAP = {
         "pubid:gost:interstate-standard" => "Pubid::Gost::Identifiers::InterstateStandard",
         "pubid:gost:national-standard"   => "Pubid::Gost::Identifiers::NationalStandard",