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

data/lib/pubid/nist/preprocessor.rb

@@ -37,6 +37,11 @@ module Pubid
       def initialize(input)
         @input = input.to_s.strip
         @cleaned = Core::UpdateCodes.apply(@input, :nist)
+        # The format describes the string the parser will see: capture
+        # it right after the update-codes remap, before the stages'
+        # cosmetic spacing (a dotted catalogue alias that remaps to the
+        # space form renders short; the dotted originals stay :mr).
+        @format = @cleaned.include?(".") && !@cleaned.match?(/\s/) ? :mr : :short
       end
 
       # Run every normalization stage and return a Result.
@@ -53,6 +58,14 @@ module Pubid
       # Extracted so rubocop can scope length/ABC metrics narrowly.
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       def run_stages
+        # Short-form "supprev" is the catalogue spelling of the plain
+        # supplement ("NBS CIRC 154supprev" ≡ "NBS CIRC 154sup"; the
+        # revision-bearing identity is the mr spelling "154suprev").
+        # Rewrite before the supplement/revision stages; the mr form is
+        # untouched.
+        if detected_format == :short
+          @cleaned = @cleaned.gsub("supprev", "sup")
+        end
         normalize_spurious_u_suffix!
         normalize_publisher_and_series!
         normalize_lcirc_supplement_contexts!
@@ -75,12 +88,14 @@ module Pubid
         normalize_part_notation!
         normalize_series_specific_spacing!
         normalize_verbose_keywords!
+        normalize_legacy_corpus_spellings!
       end
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
-      # Detect input format: :mr (dot-separated machine-readable) or :short.
+      # Detect input format: :mr (dot-separated machine-readable) or
+      # :short. Frozen in #initialize (post update-codes, pre-stages).
       def detected_format
-        @input.include?(".") && !@input.match?(/\s/) ? :mr : :short
+        @format
       end
 
       private
@@ -167,12 +182,21 @@ module Pubid
       # Trailing "-a" → "-A" at end of identifier.
       def uppercase_dash_letter!
         @cleaned = @cleaned.gsub(/(\d)-([a-z])$/) { "#{$1}-#{$2.upcase}" }
+        # Same letter when a part tail follows ("-add", " Add."), so the
+        # canonical case survives; lowercase update/translation codes
+        # ("-upd", ".uppl") never match (next char is a letter).
+        @cleaned = @cleaned.gsub(/(\d)-([a-z])(?=[-.\s])/) { "#{$1}-#{$2.upcase}" }
       end
 
       # Trailing "a" → "A" when attached directly to a digit (excludes
       # "r" to preserve revision+year patterns like "73-197r").
       def uppercase_trailing_letter!
         @cleaned = @cleaned.gsub(/(\d)([a-z&&[^r]])$/) { "#{$1}#{$2.upcase}" }
+        # Same letter when an addendum tail follows ("-add", " Add."),
+        # so the canonical part case survives ("800-38a-add" ->
+        # "800-38A"); part digits ("800-85a-1") and update/translation
+        # codes ("-upd", ".uppl") never match.
+        @cleaned = @cleaned.gsub(/(\d)([a-z&&[^r]])(?=\s*[-.\s]\s*[aA]dd)/) { "#{$1}#{$2.upcase}" }
       end
 
       # Letter suffix on revision: "22r1a" → "22r1A".
@@ -336,6 +360,33 @@ module Pubid
         end
       end
 
+      # Legacy corpus spellings: catalogue forms the mr grammar and the
+      # renderers cannot round-trip on their own. Each rule mirrors an
+      # already-parseable spelling of the same document.
+      def normalize_legacy_corpus_spellings!
+        # The mr renderer prints the translation code with its own
+        # leading dot ("955-S..uppl"); the parser wants one dot.
+        @cleaned = @cleaned.gsub("..", ".")
+        # Trailing-dot addendum spelling; the canonical render comes from
+        # the lowercase ".add" parse ("NBS.TN.467pt1.Add." -> ".add").
+        @cleaned = @cleaned.gsub(/\.Add\.\z/, ".add")
+        # Edition glued to the series in mr form ("NBS.CIRCe2" is
+        # "NBS.CIRC.e2"; digits before "e" are untouched: "24e7", and
+        # the short form never glues an edition to a letter part:
+        # "150-1Ae2009").
+        if detected_format == :mr
+          @cleaned = @cleaned.gsub(/([A-Z])e(\d)/, '\1.e\2')
+        end
+        # Update markers without a number render a phantom "1";
+        # "…-upd" is the numberless spelling of "…-upd1".
+        @cleaned = @cleaned.gsub(/-upd\z/, "-upd1")
+        # Handbook legacy renumbering in the all-dash spelling: the
+        # e-form stage already eats the prefix generically ("HB
+        # 150-1e2017" -> "HB 1-2017"); the all-dash form carries the
+        # same 105-/150- prefixes.
+        @cleaned = @cleaned.gsub(/\b(NIST HB\s+)(?:105|150)-(\d+)-(\d{4})(?=\s|\z)/, '\1\2-\3')
+      end
+
       # Series-specific reverts: HB handbooks, OWMWP dates, and RPT year
       # ranges use dash-year structurally (not as an edition marker), so
       # the broad convert_dashyear_to_edition! rule would corrupt them.

data/lib/pubid/nist/series/ir.rb

@@ -31,9 +31,7 @@ module Pubid
                                              letter_suffix:)
           return false unless letter_suffix == "R"
 
-          identifier.number = Components::Code.new(
-            value: "#{first_num.value}-#{letter_base}",
-          )
+          identifier.number = "#{first_num.value}-#{letter_base}"
           edition_obj = Components::Edition.new(type: "r", id: "1")
           identifier.edition = edition_obj
           true
@@ -42,13 +40,11 @@ module Pubid
         def self.finalize_identifier(identifier, _parsed_hash)
           return unless identifier.number
 
-          value = identifier.number.value.to_s
+          value = identifier.number.to_s
           match = value.match(/^(\d+)e(\d{4})$/)
           return unless match
 
-          identifier.number = Components::Code.new(
-            value: "#{match[1]}-#{match[2]}",
-          )
+          identifier.number = "#{match[1]}-#{match[2]}"
           identifier.edition = nil
         end
       end

data/lib/pubid/oasis/CLAUDE.md

@@ -0,0 +1,19 @@
+# OASIS flavor notes
+
+OASIS verbatim slugs, the index key, the MR slug and partial-reference matching.
+
+Read them before you change `lib/pubid/oasis/` or `spec/pubid/oasis/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **The identity is the verbatim slug; the decomposition is a lossy projection of it**: an OASIS identifier is a free-form slug with no fixed internal order (`OSLC-CoreShapes-3.0-PS01-Pt8`, `OSLC-AM-3.0-Part1-PS01`, `amqp-core`), three part spellings and mixed case. The grammar therefore captures the whole slug with `any.repeat(1)` and only strips the `OASIS ` prefix; `Builder#decompose` then classifies each *whole* dash-separated fragment into `number` / `version` / `stage` / `part` / `label`. **`original` holds the printed slug verbatim and alone drives `to_s` and `to_urn`** — `Renderer#render` is a pure echo of it — so the printed form round-trips byte-exactly whatever the classifier makes of it. The decomposition is **not** an identity and cannot be one: it loses fragment order (`x-1.0-os-Pt1` and `x-1.0-Pt1-os` decompose alike) and keeps only the first fragment of each recognized kind, so a repeated one is dropped. That is not hypothetical — **7 of the 605 published `relaton-data-oasis` ids already lose a fragment** (`OASIS xacml-3.0-hierarchical-v1.0-CS02` keeps `3.0` and drops `v1.0`). Every design decision below follows from that asymmetry.
+
+- **`spec` → `number`, the index key (PR #359)**: `Relaton::Index::Type#candidates_by_number` sorts every row and binary-searches it on `id.root.number.to_s`. OASIS kept the specification name in a bespoke `attribute :spec, :string` and never set the `number` it inherits from `::Pubid::Identifier`, so **all 605 published rows shared the empty key `""`** and the search degraded to a linear scan, silently. The attribute is **renamed**, not shadowed by a derived reader: `attribute :number, :string` plus `map "number", to: :number`, and `Builder#decompose` returns `number:`. **`spec` is dropped with no alias and no reader** — one name for one value, the W3C `code` → `number` precedent. A derived `#spec` was written first and then removed: nothing in `lib/` read it, and `relaton-oasis` has no pubid dependency at all, so it had no consumer to preserve. That is what separates this case from IANA's `#registry`, IETF's `#series` and BIPM's `#volume`, which do have one. `root_number_spec.rb` asserts the identifier does **not** respond to `spec`, so the name cannot creep back. The key **clusters**: every version, stage and part of one specification shares it — 309 buckets over 605 ids, median 1, max 25 (`STIX`) — the shape of an IETF draft slug or an IANA registry slug, not an exact key.
+
+- **Why the `number` declaration sits on the base here**: `attribute :number, :string` redefines the parent's `Components::Code number` on a class `Identifiers::Standard` inherits from, which is the recorded determinism landmine. It is safe for the same reason W3C's is: lutaml deep-dups the parent attribute table into each subclass at class-definition time, so a subclass holds a snapshot, and Ruby resolves the superclass constant to completion before opening a leaf body. **`Pubid::Oasis::Identifier`'s class body lives in one file and is never reopened**, so the snapshot is always complete. `stage` and `part` in that same body have relied on this since the flavor landed, overriding `Components::Stage` and `Components::Code`. **Split this class across two files and the landmine comes back** — IEEE is the counter-shape, its base reachable through two paths. `spec/pubid/oasis/root_number_spec.rb` carries the structural tripwire (the base *and* the leaf must resolve `number` to `Lutaml::Model::Type::String`) and is only meaningful under the full `bundle exec rake`.
+
+- **MR slug**: OASIS supplied no `mr_*` hook, and every base hook looks for something the flavor does not use — the publisher is the `PUBLISHER` constant rather than a lutaml attribute, there is no `Components::Date` and no `typed_stage`. With `number` nil as well, **`to_mr_string` was `""` for all 605 ids**, and `to_slug` is what consumers use as an output **filename**. The base now supplies `mr_publisher` (`"oasis"`) and `mr_number_with_part`, which returns the sanitized **`original`** — not the five decomposed fields, because those assemble `x-1.0-os-Pt1` and `x-1.0-Pt1-os` into one slug, while `original` cannot collide. A private `mr_sanitize` filters **by charset**, so a field added later cannot leak an unsafe character. It uses **BIPM's `[^a-z0-9]+` form, not ETSI's `[^a-z0-9-]+`**: a run of non-alphanumerics collapses to one `-`, without which `v3.0]-PS01` prints a bare `--`. Three characters need the filter today — the `.` in every version (`Renderers::MrString` joins *segments* with `.`, so a dot inside one breaks the documented structure), plus the space and `]` of a few malformed records. Result: **605 distinct slugs for the 605 published ids, 0 raises, 0 characters outside `[a-z0-9._-]`**. One caveat, the same one BIPM records: `-` is both the intra-slug join and the substitute, so two slugs differing only in which non-slug character they use collapse. The corpus has exactly one such pair — the malformed `OpenC2-MQTT-v1.0] -CS01` spelled once with a normal space and once with a non-breaking one, two spellings of one document.
+
+- **`#exclude` clears `original`, so a partial reference can widen**: `#matches?` is `exclude(*ignore) == other.exclude(*ignore)`, and `original` spells out verbatim the very component the caller is ignoring. So it survived the exclusion and a bare `OASIS WSDM` could **never** match `OASIS WSDM-v1.1`, however much was ignored — relaton would narrow to the right index bucket and then match nothing in it. `Pubid::Oasis::Identifier#exclude` now nils `original` when the excluded set intersects `DECOMPOSITION_KEYS` (`number version stage part label`), the "reset the whole cluster" rule CSA applies to its year-format siblings. **A plain `==` still compares `original`, deliberately**: an excluded copy is a comparison token, never a rendered document, so widening happens only when the caller asks for it. Dropping `original` from `==` outright was considered and rejected — it costs nothing on today's corpus (no two ids collide) but it exposes those 7 lossy ids to a silent collision with a future sibling, and it would let two different printed identifiers be equal. `spec/pubid/oasis/partial_ref_spec.rb` locks both halves.
+
+- **relaton note**: nothing published needs migrating. `relaton-oasis` has no pubid dependency and its `index-v1.yaml` is string-keyed (`:id: OASIS amqp-core`), which is why the serialized shape was changed properly rather than patched. There is **no alias** for the old `spec` key, and a pre-`number` row would deserialize with a nil `number` and no error (lutaml ignores unknown keys), so a future pubid index must be crawled *after* this. Rendering is the loud failure if it is not.
+
+- **Verification and the fixture net**: the change was verified by replaying a `main` baseline over all 605 published ids plus the fixture lines — `to_s`, `to_urn`, identifier class and parse errors **byte-identical**, `to_hash` differing **only** by the key rename, empty index keys 607 → 0, distinct MR slugs 1 → 606 of 607, and `from_hash(to_hash) == id` for all 605 with **0** pairs of distinct ids equal. `spec/pubid/oasis/fixtures_spec.rb` is live — its glob is correct, so OASIS is not on the `ten-dead-fixture-specs` list — and `root_number_spec.rb` adds a corpus sweep over the same file. **Do not run `rake "validation:classify[oasis]"`**: there is no `spec/fixtures/oasis/identifiers/full/`, so the generator would delete `pass/oasis.txt` and rebuild nothing. (hand-off: oasis-index-number.)

data/lib/pubid/oasis/builder.rb

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

data/lib/pubid/oasis/identifier.rb

@@ -36,6 +36,18 @@ module Pubid
       # building the table before `Identifiers::Standard` snapshots it — DO NOT
       # split this class across two files.
       attribute :number, :string
+
+      # `original` alone drives #to_s, and the shared exclude-copy loses it
+      # (the redefined attribute does not survive the rebuild). An all-parts
+      # copy is therefore dup-based: nil the part and edition-ish attributes
+      # in place, keeping the printed slug verbatim.
+      def without_parts(*extra)
+        copy = dup
+        (::Pubid::Identifier::PART_ATTRIBUTES + extra).each do |name|
+          copy.public_send(:"#{name}=", nil) if copy.respond_to?(:"#{name}=")
+        end
+        copy
+      end
       attribute :version, :string
       attribute :stage, :string
       attribute :part, :string
@@ -91,6 +103,13 @@ module Pubid
         result
       end
 
+      # The same reason applies to a subset match: `original` spells out the
+      # parts a partial reference omits, so `===` compares the decomposition
+      # only. Two slugs that decompose alike therefore match each other.
+      def self.subset_ignored_attributes
+        %i[original]
+      end
+
       # MR string hooks. `to_slug` delegates to `to_mr_string` and consumers
       # use it as an output FILENAME, so the slug must be unique per document.
       #

data/lib/pubid/ogc/CLAUDE.md

@@ -0,0 +1,34 @@
+# OGC flavor notes
+
+OGC `all_parts_edition_keys`: `year` is core identity, not an edition marker.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/ogc/` or `spec/pubid/ogc/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **`all_parts_edition_keys` needed `revision` added AND `year` kept OUT — the
+  hand-off's own suggested override was wrong about the second half.**
+  `Identifier.all_parts_edition_keys` defaults to `%i[date year edition
+  version]`. OGC's real edition/version discriminator is `revision`
+  ("r19" in "12-128r19"), which that list never covered, so
+  `"12-128r19".to_all_parts` did not collapse onto another revision of
+  the same document. But `year` is **also** in the default list, and for
+  OGC `year` is NOT an edition marker — it is the document's core
+  `"<yy>"` identity token, the first half of the `"12-128"` core that
+  `Renderer#render` requires (`"#{id.year}-#{id.number}"`). Stripping it
+  (as the default list does, and as the hand-off's suggested override
+  `%i[date year edition version revision]` would have kept doing) drops
+  the prefix: `to_all_parts.to_s` rendered `"-128r19 (all parts)"`
+  instead of `"12-128 (all parts)"`. The two symptoms — the missing
+  prefix and the un-stripped revision — are the SAME root cause
+  (`year` wrongly treated as a stripped key), not two separate issues,
+  despite looking that way in the original repro. The correct override
+  replaces the list entirely rather than extending it:
+  ```ruby
+  def self.all_parts_edition_keys
+    %i[revision]
+  end
+  ```
+  `date`/`edition`/`version` are harmless to omit — OGC declares none of
+  them as attributes, and `#exclude` (which `without_parts` is built on)
+  silently skips a name a class doesn't declare. Locked by
+  `spec/pubid/ogc/all_parts_spec.rb` and
+  `spec/pubid/all_parts_edition_keys_audit_spec.rb`.

data/lib/pubid/ogc/builder.rb

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

data/lib/pubid/ogc/identifier.rb

@@ -16,6 +16,17 @@ module Pubid
       # its separator letter: "r1", "c1", "a", "r3a", "r12a". nil when absent.
       attribute :revision, :string
 
+      # `revision` is OGC's edition/version discriminator, not the default
+      # `%i[date year edition version]`. `year` IS in that default list, but
+      # here it is the document's core "<yy>" identity token — the renderer
+      # requires it to print the "12-128" core (lib/pubid/ogc/renderer.rb) —
+      # not an edition marker, so it must stay OUT of the stripped set. Do
+      # not "fix" this by adding :revision to the base default; that keeps
+      # :year in the list and reproduces the dropped-prefix bug.
+      def self.all_parts_edition_keys
+        %i[revision]
+      end
+
       # Polymorphic type map for lutaml::Model key_value (de)serialization: maps
       # the concrete class's polymorphic_name to its class name so a stored hash
       # rebuilds the correct identifier type via from_hash.

data/lib/pubid/oiml/CLAUDE.md

@@ -0,0 +1,189 @@
+# OIML flavor notes
+
+OIML index key, bulletins and supplement URNs.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/oiml/` or `spec/pubid/oiml/`. 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"
+
+**(5) OIML `Bulletin` is the one leaf with no code** (its locator is the year/issue/sequence tuple), so it deliberately does **not** include `CodeNumber`. Its key was first the year, as a derived reader; it is now the issue, stored as `number`. The section "Bulletin: the issue is the `number`" below records why. **(6) A pre-existing OIML crash closed in passing**: `Pubid::Oiml::SupplementIdentifier` descends from `Oiml::Identifier` **directly** — it is a *sibling* of `SingleIdentifier`, where `code` and `iteration` live — while `UrnGenerator` reads both unconditionally, so `to_urn` **raised `NoMethodError`** for every Amendment/Errata/Annex (confirmed on the `main` baseline: all five supplement fixtures already raised). Two delegations (`code`/`iteration` → `base&.…`) fix it. **Two gaps deliberately left open and pinned** by expectations in `root_number_spec.rb` that assert the *current* behaviour, so a future fix must flip them: the OIML URN encodes no supplement marker, so an annex, an amendment and their base share one URN (the documented ITU supplement-URN shape); and a supplement inherits none of `SingleIdentifier`'s `mr_*` hooks, so **every** OIML supplement still slugs to `""` — a filename collision, unchanged from `main`. (follow-up hand-off: oiml-supplement-identity-surfaces.)
+
+## Bulletin: the issue is the `number`
+
+**The problem.** The first design derived `Bulletin#number` from `date&.year` as a reader, and did not serialize it, so that `year` did not repeat in each row. The runtime key was correct: relaton keys on `root.number.to_s`, and 4133 of the 4134 Bulletin rows of the published `relaton-data-oiml` `index-v2.yaml` keyed on their year. But a scan of the raw YAML reported **4134 rows with no `number`**, and a reader of the index could not see the key.
+
+**The change.** The year is the volume and the issue is the number, as in the citation form `LXVII(2)`. So the attribute `issue` became `attribute :number, :string`, mapped as `"number"`, and the derived year reader was deleted. Nothing new is stored: the value moved from the `issue` key to the `number` key. No `issue` method remains, and the constructor refuses an `issue:` key: in Ruby and in the hash, the name is `number`. The attribute is declared on the Bulletin **leaf**, which has no subclasses, so the multi-flavor determinism landmine does not apply (the `CodeNumber` pattern).
+
+**No legacy read.** pubid does not read the old `issue` key, by decision. lutaml ignores a key that no attribute maps, and it raises no error. So an old row loads WITHOUT its issue and becomes a different identifier: `{year: "1960", issue: "03", sequence: "01"}` renders as `OIML Bulletin 1960-01`, with URN `urn:oiml:bulletin:1960-01` and no index key. The published `relaton-data-oiml` `index-v2.yaml` must therefore be crawled again when this change is released, before relaton uses it for a Bulletin lookup.
+
+**The trade-off, measured on the 4134 published Bulletin rows:**
+
+- Rows with no `number`: 4134 → 68. These are the 67 volume rows (`OIML Bulletin 1960`) and the bare `OIML Bulletin`, which name no issue. Their key is `""`, and they share one bucket.
+- The largest bucket: 112 → 1215. The key puts the same issue number of all volumes together (all `01` issues), so relaton's filter reads more rows after the binary search. The binary search stays valid.
+- The MR slug does not change (`oiml.bulletin.03-01.1960`): `mr_number_with_part` emits `number`-`sequence` and not the year, which `Renderers::MrString` gives its own segment. The slug keeps each article distinct.
+
+**Verified** by replaying a baseline captured on `main` over all 5646 published rows (each Bulletin `issue` key renamed to `number`, as a new crawl writes it) and every OIML fixture: `to_s`, `to_urn`, `to_mr_string` and the class are identical; a Bulletin `to_hash` differs only by `issue` → `number`; `from_hash(to_hash) == id` did not change for any entry. Locked by the "Bulletin keys on its issue" block of `spec/pubid/oiml/root_number_spec.rb`.
+
+**Relaton note (not caused by this change).** `Relaton::Oiml::Bibliography#pubid_match?` compares `exclude(:year, :language).to_s`. For a Bulletin that string is `"OIML Bulletin"` for every article, so a query can return a different article of the same year (hand-off `relaton__relaton__oiml-bulletin-pubid-match`).
+
+## 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`, `subpart` and `suffix` are strict**, so `OIML R 138` does not
+  match `OIML R 138-Amend:2009`, which is its amendment, and
+  `OIML R 137-1 (F)` does not match `OIML R 137-1-2:2012 (F)`, which names a
+  subpart it doesn't. The declaration rides the `Identifiers::CodeNumber`
+  mixin (`lib/pubid/oiml/identifiers/code_number.rb`), so it reaches all
+  seven leaves that install the columns; `Bulletin`, which does not include
+  the mixin, is unaffected. `Oiml::Components::Code` carries the same
+  declaration for the shapes not to drift, although `===` does not reach it
+  today.
+- **`language` is strict**, declared separately on `SingleIdentifier` and
+  `SupplementIdentifier` (each declares its own `language` attribute), so
+  `OIML R 126:2015 Errata` does not match `OIML R 126:2015 Errata (E)`, its
+  English edition. It could not be declared once on the shared `Identifier`
+  ancestor: `spec/pubid/subset_match_spec.rb`'s "names only attributes the
+  class declares" check requires every `subset_strict` name to be a real
+  attribute on the declaring class, and `Identifier` itself declares neither
+  `language` nor `letter`.
+- **`Annex#letter` is strict**, so `OIML R 102 Annexes` (no letter — the
+  plural form) does not match `OIML R 102:1995 Annex B-C`, which names one.
+  Found in review alongside the `language`/`subpart` work above: same bug
+  shape, on the one OIML attribute besides `language` that names a specific
+  sub-document and had no `subset_strict` declaration.
+
+## Subset match: ignored render flags
+
+`parsed_format` (`SingleIdentifier`/`SupplementIdentifier`), `year_on_base`
+(`Annex`), `space_suffix` (`CodeNumber` mixin / `Components::Code`),
+`trailing` and `joined` (`SupplementIdentifier`) are Boolean or string
+attributes with a non-nil default that record which of two equivalent input
+spellings a reference used (short vs long format, dash- vs space-separated
+suffix, trailing-word vs prose supplement form, year glued to the base vs to
+the marker) — never something the document itself states. Left alone, their
+non-nil default reads as "stated" to `===` even in a bare reference (the
+CSA/IEEE year-format trap `docs/SUBSET_MATCH.md` describes), which is why
+`OIML R 102 Annex B-C === OIML R 102:1995 Annex B-C` used to disagree with
+relaton's own OIML match on `year_on_base` alone. They are listed in
+`Oiml::Identifier.subset_ignored_attributes` (`lib/pubid/oiml/identifier.rb`)
+as one shared list on the flavor's common ancestor: a name that isn't an
+attribute of a given leaf (e.g. `year_on_base` only exists on `Annex`) is a
+harmless no-op there, since `===` only walks `self.class.attributes`.
+
+**Measurement that drove this** (hand-off
+`metanorma__pubid__oiml-subset-match-strict-language.md`): relaton compared
+`===` against its own OIML match over the full 5,646-row `relaton-data-oiml`
+index (4.57M pairs) and found 192 disagreeing pairs outside the Bulletins —
+156 on `language`, 6 on `subpart`, 30 on `year_on_base` — all wrong on the
+`===` side before this branch.
+
+## Dual-published identifiers: OIML co-publication with another SDO (pubid #437)
+
+**The shape.** OIML sometimes co-publishes a document jointly with another
+SDO — ISO confirmed so far. The printed reference carries both identifiers,
+joined by a bare `|`, e.g. `ISO 4064-1:2024|OIML R 49-1:2024`. Both sides
+name the same document, each in its own SDO's scheme.
+
+**`Identifiers::DualPublished` is a THIRD sibling** of `SingleIdentifier`/
+`SupplementIdentifier` under `Oiml::Identifier` — same shape as
+`SupplementIdentifier`, and the same lesson applies: it inherits **nothing**
+from `SingleIdentifier`, so every identity-bearing reader `UrnGenerator` or
+the MR-slug renderer calls (`code`, `type`, `stage`, `iteration`,
+`publisher`, and the `mr_publisher`/`mr_type`/`mr_number_with_part`/
+`mr_year` hooks, plus `#root`) is hand-delegated to whichever side is OIML.
+Without the `mr_*` delegations this class would have shipped with the exact
+same empty-slug gap already recorded above for Amendment/Errata/Annex; this
+class closes it from day one instead of reproducing it.
+
+**`first`/`second` hold the two sides in original left-to-right print
+order**, each a real `attribute ..., ::Pubid::Identifier, polymorphic: true`
+— never an `attr_accessor` (see IEEE's `CsaDualPublished`, which used one
+and silently dropped its second identifier from `to_hash`/`from_hash`/
+`#exclude`). `#oiml_identifier`/`#external_identifier` pick the OIML-typed
+member out of the pair by `is_a?`, not by position, since nothing guarantees
+which side prints first.
+
+**`language`/`parsed_format` are declared locally even though this class
+never sets them.** `Oiml::Identifier`'s shared `key_value` block (inherited
+by every OIML class) maps `"language"` and `"parsed_format"` to real
+attributes; a subclass's own `key_value` block **merges** with its parent's
+rather than replacing it, so `to_hash`/`from_hash` would call
+`model.language`/`model.language=` regardless of what this class declares.
+Leaving them undeclared would crash `to_hash` outright (no such method);
+delegating `language` as a read-only method would crash `from_hash` (no
+setter). `SingleIdentifier` and `SupplementIdentifier` both declare these
+locally for the same reason — this class follows the same pattern rather
+than inventing a new one.
+
+**Parse dispatch lives in `Pubid::Oiml.parse`/
+`Identifiers::DualPublished.build`, not the Parslet grammar.** The string is
+split on `|` before the grammar ever runs; the side that matches `PREFIXES`
+(`["OIML"]`) is parsed via `Oiml.parse` (re-entering this same module
+method — safe, since the substring has no `|`), the other via the generic
+top-level `Pubid.parse`, which auto-routes to any flavor by prefix. `.build`
+returns `nil` for anything that isn't exactly two non-empty sides with
+exactly one OIML side, letting the caller fall through to the ordinary
+grammar — which has no `|` rule, so it raises the standard
+`Parslet::ParseFailed`, keeping the uniform parse-error contract intact. The
+side is detected by content, not position, so `OIML R 49-1:2024|ISO
+4064-1:2024` parses identically in the other order.
+
+**The URN represents only the OIML side** (`urn:oiml:...`) — there is no
+joint URN scheme anywhere in this codebase, matching every other
+cross-flavor wrapper (IEEE's `AdoptedStandard`/`MultiNumberedIdentifier`).
+One generator change was required: `UrnGenerator::Base#urn_year` gates on
+`identifier.class.attributes.key?(:date)`, and `DualPublished` declares no
+`date` of its own (it lives on whichever side is OIML) — so
+`Oiml::UrnGenerator#urn_year` special-cases the class and reads the date
+through `#oiml_identifier` directly. Every other URN segment
+(`urn_type`/`urn_number`/`urn_stage`/`urn_iteration`/`urn_language`) works
+for free through the §1 delegations, since they already read plain
+`identifier.type`/`.code`/etc. rather than going through the attributes
+registry.
+
+**`(de)serialization goes through `Pubid.from_hash`/`#to_hash`, not the
+OIML-scoped `Identifier.from_hash`**, because either side of `first`/
+`second` may belong to any flavor — `Identifier.from_hash` only resolves
+OIML `_type` values. Verified this round-trips both an OIML-native nested
+hash and a foreign one via the shared global `TypeResolver`.
+
+**Known, deliberately out-of-scope gaps**, matching the issue's one
+confirmed example (a plain `Recommendation` on the OIML side, no edition):
+
+- An OIML side that is itself a Amendment/Annex/Errata
+  (`SupplementIdentifier`) is untested — the delegation chain should mostly
+  work transitively, but this hasn't been exercised.
+- Only two-way co-publication is modeled (two fixed attributes), not
+  three-or-more.
+- **`edition` is not delegated**, unlike `code`/`type`/`stage`/etc. This is
+  deliberate, not an oversight: OIML's own `edition` is a plain `:string`
+  attribute (`SingleIdentifier`), but the shared `#mr_edition`/`#urn_edition`
+  (`lib/pubid/identifier.rb`, `lib/pubid/urn_generator/base.rb`) assume the
+  `Components::Edition` shape and call `edition.number` — a **pre-existing**
+  bug in OIML itself: `Pubid::Oiml.parse("OIML E 5 6th Edition 2015
+  (E)").to_mr_string` already raises `NoMethodError` on `main`, with no
+  `DualPublished` involved. Delegating `edition` here would only reproduce
+  that crash through a second path; leaving it undelegated means an
+  edition-bearing OIML side silently drops its edition from the MR slug/URN
+  instead of raising — worse data loss, but no new crash surface. Fixing the
+  root cause (OIML's edition/MR-edition type mismatch) is unrelated to
+  dual-published identifiers and is left for its own change.
+- **Annotated rendering (`to_s(annotated: true)`) only spans the OIML
+  side's publisher/type**, not its number/year, and not the external side at
+  all. This matches — not regresses — the existing shipped behavior of the
+  closest precedent, IEEE's `Identifiers::AdoptedStandard`: `Renderers::
+  Annotator#nested_identifiers` (`lib/pubid/renderers/annotator.rb`) only
+  recurses into `base`/`ids`/`identifiers`/`bundled_with`, none of which
+  `DualPublished` (or `AdoptedStandard`, which uses `ieee_identifier`/
+  `adopted_identifiers`) uses, so neither wrapper's nested sides get full
+  token annotation. The uniform contract this repo enforces is narrower than
+  full annotation: every `to_s` must **accept** `annotated:` without
+  raising, which this class does (verified by a spec). Widening
+  `Annotator#nested_identifiers` to close this for every such wrapper at
+  once is a separate, cross-flavor change.

data/lib/pubid/oiml/builder.rb

@@ -16,6 +16,9 @@ module Pubid
       }.freeze
 
       def build(parsed_hash)
+        # Certification-system documents carry no type letter
+        return build_cs(parsed_hash) if parsed_hash[:cs_series]
+
         # Check for short amendment format (has amd_marker)
         if parsed_hash[:amd_marker]
           return build_short_amendment(parsed_hash)
@@ -32,6 +35,20 @@ module Pubid
 
       private
 
+      # OIML-CS documents: family (PD/OD/CID), zero-padded number, the
+      # printed "Edition N", and an optional parenthesized trailing
+      # amendment. The family-number separator is a spelling flag.
+      def build_cs(parsed_hash)
+        identifier = Identifiers::CertificationSystem.new
+        identifier.publisher = parsed_hash[:publisher].to_s if parsed_hash[:publisher]
+        identifier.family = parsed_hash[:cs_family].to_s
+        identifier.number = parsed_hash[:number].to_s
+        identifier.edition = parsed_hash[:edition].to_s if parsed_hash[:edition]
+        identifier.amendment = parsed_hash[:cs_amendment].to_s if parsed_hash[:cs_amendment]
+        identifier.space_separator = parsed_hash[:cs_separator] == " "
+        identifier
+      end
+
       def build_short_amendment(parsed_hash)
         # Build base identifier from the code and type
         base_hash = {
@@ -110,6 +127,7 @@ module Pubid
 
         # Set supplement-specific attributes
         supplement.year = year_value.to_s if year_value
+        supplement.number = parsed_hash[:number].to_s if parsed_hash[:number]
         supplement.language = extract_language(parsed_hash[:language]) if parsed_hash[:language]
         supplement.letter = parsed_hash[:annex_letter].to_s if parsed_hash[:annex_letter]
 
@@ -228,13 +246,13 @@ module Pubid
           article_id = parsed_hash[:article_id].to_s
           identifier.date ||= Pubid::Components::Date.new
           identifier.date.year = article_id[0, 4]
-          identifier.issue = article_id[4, 2]
+          identifier.number = article_id[4, 2]
           identifier.sequence = article_id[6, 2]
           warn_on_volume_mismatch(identifier, parsed_hash[:volume_roman])
           return
         end
 
-        identifier.issue = parsed_hash[:issue].to_s if parsed_hash[:issue]
+        identifier.number = parsed_hash[:issue].to_s if parsed_hash[:issue]
         identifier.sequence = parsed_hash[:sequence].to_s if parsed_hash[:sequence]
       end
 
@@ -268,3 +286,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Oiml::Builder.prepend(Pubid::Builder::AllPartsWrap)

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

@@ -10,6 +10,8 @@ module Pubid
       # shape is otherwise compatible; a future rename of +number+ →
       # +value+ would let this become a subclass.
       class Code < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :number, :string
         attribute :part, :string
         attribute :subpart, :string
@@ -20,6 +22,10 @@ module Pubid
         # the default dash ("R 60-sup").
         attribute :space_suffix, :boolean, default: false
 
+        # Mirrors the flat columns the CodeNumber mixin installs on the
+        # seven leaves, which own the identity.
+        subset_strict :part, :subpart, :suffix
+
         def to_s
           result = number.to_s
           result += "-#{part}" if part

data/lib/pubid/oiml/identifier.rb

@@ -12,6 +12,7 @@ module Pubid
         "pubid:oiml:basic-publication" => "Pubid::Oiml::Identifiers::BasicPublication",
         "pubid:oiml:bulletin" => "Pubid::Oiml::Identifiers::Bulletin",
         "pubid:oiml:document" => "Pubid::Oiml::Identifiers::Document",
+        "pubid:oiml:dual-published" => "Pubid::Oiml::Identifiers::DualPublished",
         "pubid:oiml:guide" => "Pubid::Oiml::Identifiers::Guide",
         "pubid:oiml:vocabulary" => "Pubid::Oiml::Identifiers::Vocabulary",
         "pubid:oiml:expert-report" => "Pubid::Oiml::Identifiers::ExpertReport",
@@ -19,6 +20,7 @@ module Pubid
         "pubid:oiml:amendment" => "Pubid::Oiml::Identifiers::Amendment",
         "pubid:oiml:errata" => "Pubid::Oiml::Identifiers::Errata",
         "pubid:oiml:annex" => "Pubid::Oiml::Identifiers::Annex",
+        "pubid:oiml:certification-system" => "Pubid::Oiml::Identifiers::CertificationSystem",
       }.freeze
 
       # The base Pubid::Identifier no longer auto-maps attributes, so OIML must
@@ -34,6 +36,17 @@ module Pubid
         map "parsed_format", to: :parsed_format
       end
 
+      # Rendering-only flags: each records which of two equivalent input
+      # spellings a document used (short vs long format, dash- vs
+      # space-separated suffix, trailing-word vs prose supplement form, year
+      # glued to the base vs to the marker), not something the document
+      # itself states. Their non-nil default would otherwise read as
+      # "stated" in a bare reference and wrongly refuse a candidate that
+      # sets them (the CSA/IEEE year-format trap).
+      def self.subset_ignored_attributes
+        %i[parsed_format year_on_base space_suffix trailing joined]
+      end
+
       # lutaml's polymorphic_map only validates `_type` on deserialization; it
       # does not re-instantiate the concrete subclass. Route by `_type` so
       # `Pubid::Oiml::Identifier.from_hash(h)` returns the right class (and its

data/lib/pubid/oiml/identifiers/annex.rb

@@ -15,6 +15,10 @@ module Pubid
           map "year_on_base", to: :year_on_base
         end
 
+        # A nil `letter` means the plural "Annexes" reference, not "any
+        # annex": it must not match a candidate naming a specific one.
+        subset_strict :letter
+
         def supplement_type
           letter ? "Annex #{letter}" : "Annexes"
         end