pubid 2.0.5 → 2.0.7

data/lib/pubid/astm/pubid_urn_schema.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    # The pubid-scheme URN of ASTM (issue #656; docs/URN-SCHEMES.adoc).
+    #
+    #   ASTM E2938-15(2023)
+    #   urn:pubid:astm:std:2938:letter-E:year-2015:reapproval-2023
+    #
+    # The core is the document number; every other value is an optional
+    # prefixed atom. Each suffix marker ("-EB", "-EA", "DVD", the metric
+    # "M", the "TP" of a manual) names a different catalogue record, so all
+    # are atoms and none is a facet. The current urn:astm: form of #to_urn
+    # is pubid-invented and stays as it is.
+    PubidUrnSchema = Pubid::PubidUrn.define("astm") do
+      atom "publisher", "pub"
+      atom "committee", "committee"
+      atom "letter", "letter"
+      atom "subseries", "subseries"
+      atom "suffix", "suffix"
+      atom "dual_m", "metric", kind: :bool
+      atom "year", "year"
+      atom "sub_year", "subyear"
+      atom "reapproval", "reapproval"
+      atom "edition", "ed"
+      atom "supplement", "sup", kind: :bool
+      atom "tp_designation", "tp"
+      atom "format_suffix", "format"
+      atom "ea_suffix", "ea", kind: :bool
+      atom "dvd_suffix", "dvd", kind: :bool
+      atom "hol_suffix", "hol", kind: :bool
+
+      type "pubid:astm:identifier", "id"
+      type "pubid:astm:single-identifier", "single"
+      type "pubid:astm:base", "base"
+      type "pubid:astm:standard", "std"
+      type "pubid:astm:iso-dual-published", "isodual"
+      type "pubid:astm:adjunct", "adj"
+      type "pubid:astm:data-series", "ds"
+      type "pubid:astm:manual", "mnl"
+      type "pubid:astm:monograph", "mono"
+      type "pubid:astm:research-report", "rr"
+      type "pubid:astm:technical-report", "tr"
+      type "pubid:astm:work-in-progress", "wk"
+    end
+  end
+end

data/lib/pubid/astm.rb

@@ -13,6 +13,7 @@ module Pubid
     autoload :Identifiers, "#{__dir__}/astm/identifiers"
     autoload :SingleIdentifier, "#{__dir__}/astm/single_identifier"
     autoload :Parser, "#{__dir__}/astm/parser"
+    autoload :PubidUrnSchema, "#{__dir__}/astm/pubid_urn_schema"
     autoload :Builder, "#{__dir__}/astm/builder"
     autoload :Renderer, "#{__dir__}/astm/renderer"
     autoload :UrnGenerator, "#{__dir__}/astm/urn_generator"

data/lib/pubid/bipm/CLAUDE.md

@@ -11,3 +11,5 @@ These notes were part of the root `CLAUDE.md`. Read them before you change `lib/
 - **BIPM loose consumer forms (retiring `Relaton::Bipm::Id`)**: `Relaton::Bipm::Bibliography` could not use pubid as its **query** parser — it kept a bespoke regex grammar (`Relaton::Bipm::Id`) because `Pubid::Bipm.parse` rejected the spellings real references use. The grammar now accepts them, so relaton can match pubid-to-pubid like every other flavor. **All of these are NORMALIZING parses — the identifier renders back in BIPM's canonical spelling, never the input** — which is the whole point (a loose query must produce an identifier equal to the index row's), and which is exactly why they must **never** go into the byte-exact `spec/fixtures/bipm/identifiers/pass/` (the `CIPM/2005-06(REV)` precedent); their expectations live in `spec/pubid/bipm/loose_consumer_forms_spec.rb`. Six constructs: **(1) Meeting word order** — `meeting_en` gained a `<group> Meeting <n>` branch and `meeting_fr` gained a plain-`e` ordinal branch (`CIPM 111e Réunion (2022)`) and a `<group> Réunion <n>` branch, all normalizing to `CCTF 14th Meeting (1999)` / `CIPM 111<sup>e</sup> réunion (2022)`. **(2) `committee_group_fr`** — a French type name in the English (group-leading) word order (`CIPM Décision 101-1 (2012)` → `Décision 101-1 du CIPM (2012)`). Its slot in `group_leading` is **after `committee_long_en`**, which is load-bearing: `Action` and `Statement` are in *both* `TYPE_NAME_EN` and `TYPE_NAME_FR`, so the English rule must claim them first or `CIPM Action 5 (2010)` would flip to French. Like the existing French rules it sets `language: "F"` — information the user typed, which a consumer can always widen away but could never recover. **(3) `GROUP_ALIASES`** (`CCDS`→`CCTF`) and **(4) `LANGUAGE_ALIASES`** (`EN`→`E`, `FR`→`F`, longest-first in the `lang` rule so `EN` is never read as a bare `E`): both are resolved in the **builder**, so an alias never reaches an attribute and the index stores only the current name and the one-letter code. `PARSEABLE_GROUPS` (= `GROUPS + GROUP_ALIASES.keys`) is what the `group` rule alternates over; `GROUPS` itself is unchanged, so nothing else sees the alias. **(5) `si_brochure_section`** — the bare `SI Brochure` and `SI Brochure Part 1`. Neither names an edition, so **both are partial references with a nil `number`** that wildcard every edition (the date-less `CCTF REC 2` reading). `Part N` points at a section *inside* the brochure — there is no `si-brochure-part-1.yaml` upstream and relaton's `Id` deletes `:part` before comparing — so it rides in the shared `part` attribute and stays **out** of the index key, exactly as the MEP/guide `Part N.M` tail does. **A Parslet fact worth recording, because it contradicts what several comments in this repo imply**: Parslet threads `consume_all` down through an alternation, so an alternative matching only a **prefix** counts as a failure and the next one is tried — verified by reordering. `si_brochure_section` therefore cannot truncate `SI Brochure Concise` whatever its slot, and `committee_bare` could not shadow a typed form even if it came first. Alternation order decides **only** between two alternatives that both consume the *whole* input — which is exactly the `committee_long_en`-before-`committee_group_fr` case above, and the only ordering here that is genuinely load-bearing (verified: flipping it renders `CIPM Action 5 (2010)` as the French `Action 5 du CIPM (2010)`, a different record). The `BIPM ` prefix was also made **optional on the main `si_brochure` rule** (it already was on the variant rule): `si-brochure.yaml` stores its docnumber *without* it, and `Relaton::Bipm::Bibliography.search` strips a leading `BIPM ` before pubid ever sees the string — so `SI Brochure 9e v3.01 (2019/2024, E)` used to be a hard parse failure. **(6) `TYPE_WORD_ALIASES`** — a **data-corruption fix**: `Declaration`/`Déclaration` were in the `type_name_en`/`type_name_fr` alternations but **not** in `TYPE_WORD_TO_CODE` (which is built from `TYPE_NAME_EN`/`TYPE_NAME_FR`, where DECL's name is `Statement` in both languages), so `CGPM Declaration 1 (1971)` parsed with `type_code` **nil** and rendered as the corrupt `"CGPM  1 (1971)"` (double space), `Déclaration 1 du CGPM (1971)` as `" 1 de la CGPM (1971)"`. Both now map to DECL and render `Statement`. **The matching contract relaton needs** (pinned by the spec against real `index-v2` rows): committee-document and meeting rows are stored **language- and form-neutral** — verified, all 1348 + 367 — so the BIPM stem is **`pubid.exclude(:language, :form)`**, and every loose form reduces under it to the identifier rebuilt from its row. The SI Brochure is the exception: a nil-`edition` query must match *any* `SiBrochure` row, which is what `Id#id_hash`'s `{group: "SI", type: "Brochure"}` collapse already meant. **Also fixed here**: `UrnParser#build_metrologia`/`#build_si_brochure` never set the derived `number`, so a URN round-trip silently emptied the relaton index key (the shared `"flavor URN round-trip"` example only compares `to_urn`, so it was invisible) — now set from the same source the builder uses, guarded by a `presence` helper because an unfilled URN segment is `""`, not nil. **Verified**: all 7,922 published `relaton-data-bipm` rows re-parse from their own `to_s` with an identical hash, class and MR slug (0 mismatches, 0 MR collisions), and all 90 pass fixtures stay byte-exact. **Deliberately NOT changed:** `CCTF Recommendation 2009-02` still reads as the literal number `2009-02` while the index keys that document under `2` — genuinely ambiguous, since `NNNN-NN` is a real BIPM number form (`CIPM 2005-06`), so the consumer keeps a fallback. **Known pre-existing gap, deliberately untouched:** the SI Brochure URN carries only language/edition/version/years, so `Concise`, `FAQ` and `Appendix 3` — three distinct documents — already share `urn:bipm:si-brochure::::`, and the new bare/section forms join that bucket (defensibly, being partial references rather than distinct documents). Fixing it needs a URN-shape decision plus a matching `UrnParser` branch. `Pubid.parse` auto-routing does not resolve **any** BIPM form today (also pre-existing), so `PREFIXES` was left alone — adding `CCDS` there would change nothing observable. (hand-off: bipm-loose-consumer-forms; consumer follow-up: relaton__relaton__bipm-drop-id-parser-for-pubid.)
 
 - **Routing reaches BIPM (`Pubid.parse`, pubid#644)**: the note above says "`Pubid.parse` auto-routing does not resolve **any** BIPM form today … so `PREFIXES` was left alone" — that is no longer true, in two halves. **(1) `PREFIXES` gained the two SI-family series tokens** `SI Brochure` and `SI MEP`: both lead real printed references on their own (`SI Brochure 9e v3.01 (2019/2024, E)` — the spelling relaton's `Bibliography#search` strips the `BIPM ` off, per the note above — and `SI MEP 10`), and before this both parsed **directly** but the router could not route them (no prefix owner ⇒ no non-exact fallback). "Rapport" stays excluded per the ambiguous-token policy (generic French word). **(2) The quoted-title form** `BIPM "The International System of Units"` — the brochure IS titled that — is mapped onto the parseable `BIPM SI Brochure` section form by **`data/bipm/update_codes.yaml`** (the CIPM-MRA precedent), so it parses as a **partial reference** that wildcards every edition, exactly like `SI Brochure Part 1`; the bare `"The International System of Units"` maps to `SI Brochure`. Both are normalizing parses and live with the loose-forms expectations, never in the byte-exact fixtures. The **French title is deliberately not mapped**: it names the F-language record specifically, and mapping it would silently drop typed language information (the loose-forms rule above). Also note the router's prefix-owner mechanism is what makes the normalizing parses routable: `Pubid::Bipm.parse("BIPM SI Brochure")` happens to round-trip exactly, but `SI Brochure 9e …` renders with the leading `BIPM ` the input lacked — without prefix-owner status the router would reject it. (hand-off: router-printed-forms-644.)
+
+- **Corpus-cited forms + guide printings (pubid#657)**: the metanorma-bipm fetch queue cites two spellings the grammar rejected, and the 2026-11 guide update adds printings of its own. All are **parse-in forms over the existing canonical identities** — the canonical render follows the guide, nothing that already parsed changed. **(1) The em-dash meeting variant** `CGPM -- Meeting 1 (1889)`: `meeting_en` gained `<group> -- Meeting <n>` and `<group> -- <n><ord> Meeting` branches (the corpus cites only the first; the second is the same reordering over the other word order). They build through the existing `Meeting` path, so the canonical render is `CGPM 1st Meeting (1889)`. **(2) The publisher-prefixed decision** `BIPM DECN CIPM/101-1 (2012, EN)` (and `, FR`): new `committee_prefixed` rule — a **literal `BIPM`** lead (the constant publisher, deliberately NOT the `group` table, which contains BIPM and would collide with the second `group` capture), `type_abbrev`, then the body-qualified id `{group}/{number}`. Builds through `build_committee` short-form, so it equals `CIPM DECN 101-1 (2012, E)` — verified against real `index-v2` rows in `loose_consumer_forms_spec` (the corpus's citeas comes out as the BIPM-long style, which is the consumer's rendering choice, not pubid's). **(3) The guide's French body-prefixed long form** `Décision CIPM/111-10 (2022)` / `Recommandation JCRB/43-1 (2021)`: an alternative inside `committee_long_fr` (same capture name, so the same builder path — long form, language F). **The canonical French long form stays the connective spelling** (`Décision 101-1 du CIPM (2012)`) even though the guide's language-independent example prefers the body-prefixed one — the corpus freezes the connective render for what already parsed, and flipping the canonical would move frozen cases; that flip is an owner decision if the guide is adopted wholesale. **(4) SI Brochure guide forms**: the language code and the version are now OPTIONAL (`SI Brochure 9e v3.01 (2019/2024)` language-independent, `SI Brochure 9e (2019, E)` version-less — both byte round-trips with the canonical `BIPM SI Brochure ` lead), and the guide's French lead `Brochure sur le SI 9e …` parses as an alias of the `BIPM SI Brochure sur le SI …` canonical (note the lead alternation is `"BIPM SI Brochure" / "SI Brochure" / "Brochure sur le SI"` with the `["sur le SI" space]` phrase still optional after the first two — it just fails cleanly after the third). **(5) The corpus-cited ordinal-edition spelling** `SI Brochure 9th edition (2019)`: its own `si_brochure_ordinal_edition` rule (a separate branch, because the `edition` capture would otherwise bind `"9th"`); the builder strips the ordinal and appends `e`, so it normalizes onto `BIPM SI Brochure 9e (2019)`. **(6) Part numbers** (the guide's resource-specific-id numbering, `partnumbers` proposal, bipm-si-brochure#301): parts/subparts are dash forms inside `number` (`CIPM DECN 111-10-2`) and always parsed; the appendix/annex complement `CIPM DECN 112 A3[.5]` is the new optional ` A<n>[.<m>]` tail on `committee_short`, stored in the shared `appendix`/`annex` attributes (the MEP/guide tail's home), printed back byte-exactly by `appendix_segment`, folded into the URN identifier segment as `-a<n>[.<m>]` (`urn:bipm:cipm:decn:112-a3.5:2022` — unambiguous, because a bare number never carries letters; `UrnParser#split_appendix` splits it back), and joined into the MR number segment (`mr_slug` collapses the annex dot). It requires a number before it (`CIPM DECN A3` still fails). **URN deviations from the guide, deliberate**: the guide's own committee-example URNs (`urn:bipm:v1:cipm:resolution:95-2006:1`) carry a `v1` version segment and venue-qualified shapes the flavor's URNs never adopted (`urn:bipm:cipm:res:101-1:2012`, no `v1`, no venue segments — green for years, kept byte-identical); the new forms emit URNs under the EXISTING shape for the same reason, and the same applies to the brochure (`urn:bipm:si-brochure:<lang>:<edition>:<version>:<years>` vs the guide's `urn:bipm:v1:bipm:si-brochure:9:3.01:2024` — the guide strips the `e`/`v` and drops the language segment; adopting that is an index-affecting owner decision, not taken here). **One Ruby trap the URN fold exposed**: `id.number.to_s` on a String **attribute** returns the attribute itself, so building the folded segment by `<<` mutated `number` in place — every later `to_s`/`to_hash` of the same object then carried `-a3`; the fold is now interpolation, and `urn_spec` pins that a URN emission leaves `number` untouched. **The unmerged `si-brochure-id` proposal** (`SI Brochure 9`, `SI Brochure 9 (E)`, `SI Brochure 9 (2024) (F)` — bare-number edition) is NOT implemented: it conflicts with the merged guide's `9e` spelling. (hand-off: bipm-657-corpus-forms.)

data/lib/pubid/bipm/builder.rb

@@ -13,6 +13,11 @@ module Pubid
       def build(data)
         if data[:committee_short]
           build_committee(data[:committee_short], form: "short")
+        elsif data[:committee_prefixed]
+          # The corpus's "BIPM DECN CIPM/101-1 (2012, EN)" publisher-prefixed
+          # spelling names the same document as the unprefixed short form; the
+          # BIPM lead is the constant publisher, so it carries no attribute.
+          build_committee(data[:committee_prefixed], form: "short")
         elsif data[:committee_long_en]
           build_committee(data[:committee_long_en], form: "long", language: "E")
         elsif data[:committee_bare]
@@ -32,6 +37,8 @@ module Pubid
           build_si_brochure_variant(data[:si_brochure_variant])
         elsif data.key?(:si_brochure_section)
           build_si_brochure_section(data[:si_brochure_section])
+        elsif data.key?(:si_brochure_ordinal_edition)
+          build_si_brochure_ordinal_edition(data[:si_brochure_ordinal_edition])
         elsif data[:mep]
           build_mep(data[:mep])
         elsif data[:guide]
@@ -55,6 +62,8 @@ module Pubid
           year: node[:year]&.to_s&.to_i,
           language: Identifier.normalize_language(language || node[:language]),
           form: form,
+          appendix: node[:appendix]&.to_s,
+          annex: node[:annex]&.to_s,
         )
       end
 
@@ -103,11 +112,13 @@ module Pubid
       # The SI Brochure has no document number of its own, so the edition is
       # the index key — it clusters the English and French records of one
       # edition. The grammar makes `edition` mandatory here, so it is never nil.
+      # The version and the language code are optional (the guide's
+      # language-independent form), so they may be nil.
       def build_si_brochure(node)
         Identifiers::SiBrochure.new(
           number: node[:edition].to_s,
           edition: node[:edition].to_s,
-          version: node[:version].to_s,
+          version: node[:version]&.to_s,
           years: node[:years].to_s,
           language: Identifier.normalize_language(node[:language]),
         )
@@ -128,6 +139,20 @@ module Pubid
         Identifiers::SiBrochure.new(part: node[:part]&.to_s)
       end
 
+      # The guide prints the edition "9e"; the corpus-cited "9th edition"
+      # spelling is the English ordinal form of the same edition, normalized
+      # onto the canonical "9e" value. The version is absent from the input, so
+      # it stays nil and drops from the serialized hash (a partial reference).
+      def build_si_brochure_ordinal_edition(node)
+        edition = "#{node[:ordinal_edition].to_s.sub(/(st|nd|rd|th)\z/, "")}e"
+        Identifiers::SiBrochure.new(
+          number: edition,
+          edition: edition,
+          years: node[:year]&.to_s,
+          language: Identifier.normalize_language(node[:language]),
+        )
+      end
+
       # The Appendix/Annex/Part tail is the full-content spelling of the SAME
       # document, so it stays out of the key.
       def build_mep(node)

data/lib/pubid/bipm/identifiers/committee_document.rb

@@ -28,7 +28,19 @@ module Pubid
         # The group has to be in the number segment or `CCTF REC 2` and
         # `CCEM REC 2` would share a slug.
         def mr_number_with_part
-          mr_slug(group, number)
+          mr_slug(group, number, appendix_tail)
+        end
+
+        private
+
+        # The appendix/annex complement distinguishes the separately published
+        # subresources, so it joins the number segment (the language rule: what
+        # upstream stores as distinct files must slug distinctly). `mr_slug`
+        # collapses the annex dot, as it does the brochure's "v3.01".
+        def appendix_tail
+          return nil unless appendix
+
+          annex ? "a#{appendix}.#{annex}" : "a#{appendix}"
         end
       end
     end

data/lib/pubid/bipm/renderer.rb

@@ -40,10 +40,20 @@ module Pubid
         # leading space) rather than emit a double space.
         lang = id.language ? ", #{id.language}" : ""
         type = id.type_code ? " #{id.type_code}" : ""
-        "#{id.group}#{type}#{number_segment(id)}" \
+        "#{id.group}#{type}#{number_segment(id)}#{appendix_segment(id)}" \
           "#{year_segment(id, lang: lang)}"
       end
 
+      # The complement tail "{identifier} A{appendix}[.{annex}]" of the guide's
+      # resource-specific-id numbering (parts/subparts are dash forms inside
+      # `number` itself; appendices/annexes are this separate tail).
+      def appendix_segment(id)
+        return "" unless id.appendix
+
+        annex = id.annex ? ".#{id.annex}" : ""
+        " A#{id.appendix}#{annex}"
+      end
+
       def render_committee_long(id)
         if id.language == "F"
           name = Identifier::TYPE_NAME_FR[id.type_code]
@@ -79,10 +89,15 @@ module Pubid
         # to print either — just the brochure, optionally down to one part.
         return "BIPM SI Brochure#{part_segment(id)}" unless id.edition
 
+        # The version is optional (the guide's "SI Brochure 9e (2019, E)" form)
+        # and the language code too (the language-independent form), so both
+        # segments are conditional.
         phrase = id.language == "F" ? "sur le SI " : ""
         lang = id.language ? ", #{id.language}" : ""
-        "BIPM SI Brochure #{phrase}#{id.edition} #{id.version} " \
-          "(#{id.years}#{lang})"
+        result = +"BIPM SI Brochure #{phrase}#{id.edition}"
+        result << " #{id.version}" if id.version
+        result << " (#{id.years}#{lang})"
+        result
       end
 
       # Optional " Part <n>" segment of an SI Brochure section reference.

data/lib/pubid/bipm/urn_generator.rb

@@ -28,13 +28,26 @@ module Pubid
         # type_code is nil for the bare MRA form → empty type segment, mirroring
         # the empty-number-segment convention for number-less documents.
         parts = ["urn", "bipm", id.group.downcase,
-                 id.type_code.to_s.downcase, id.number.to_s]
+                 id.type_code.to_s.downcase, committee_number_segment(id)]
         # A partial (date-less) reference drops the trailing year segment; a
         # number-less-but-dated doc keeps its empty number segment.
         parts << id.year if id.year
         parts.join(":")
       end
 
+      # The appendix/annex complement folds into the identifier segment as
+      # "-a{appendix}[.{annex}]". A bare number is digits and dashes only, so
+      # the letter-prefixed tail is unambiguous on the way back (UrnParser
+      # splits it). Built by interpolation, never by appending to
+      # `id.number.to_s` — on a String attribute that returns the attribute
+      # itself, so a `<<` would mutate the identifier's `number` in place.
+      def committee_number_segment(id)
+        return id.number.to_s unless id.appendix
+
+        tail = id.annex ? ".#{id.annex}" : ""
+        "#{id.number}-a#{id.appendix}#{tail}"
+      end
+
       def meeting
         id = identifier
         parts = ["urn", "bipm", id.group.downcase, "meeting", id.number.to_s]

data/lib/pubid/bipm/urn_parser.rb

@@ -27,14 +27,27 @@ module Pubid
             group: group, number: parts[2].to_s, year: parts[3]&.to_i,
           )
         else
+          number, appendix, annex = split_appendix(parts[2])
           Identifiers::CommitteeDocument.new(
             group: group,
             type_code: (parts[1].empty? ? nil : parts[1].upcase),
-            number: (parts[2].empty? ? nil : parts[2]), year: parts[3]&.to_i
+            number: (number.empty? ? nil : number), year: parts[3]&.to_i,
+            appendix: appendix, annex: annex,
           )
         end
       end
 
+      # Inverse of UrnGenerator#committee_number_segment: splits the folded
+      # "-a{appendix}[.{annex}]" tail back out of the identifier segment. A
+      # bare number is digits and dashes only, so the letter-prefixed tail is
+      # unambiguous.
+      def split_appendix(segment)
+        match = segment.to_s.match(/\A(.+?)-a(\d+)(?:\.(\d+))?\z/)
+        return [segment, nil, nil] unless match
+
+        [match[1], match[2], match[3]]
+      end
+
       # `number` is the relaton index key and is derived, not printed, so it has
       # to be set here exactly as `Builder` sets it — a URN-reconstructed
       # identifier must agree with a parsed one attribute for attribute.

data/lib/pubid/identifier.rb

@@ -1114,6 +1114,21 @@ module Pubid
       resolve_urn_generator.new(self).generate
     end
 
+    # The lossless pubid-scheme URN ("urn:pubid:…").
+    #
+    # It is in pubid's own namespace (issue #656), carries every value of
+    # #to_hash and always round-trips through Pubid.parse_urn. Not the
+    # same as #to_urn, the official, possibly lossy URN of the
+    # organization. Defined once, here, from #to_hash and the flavor's
+    # PubidUrnSchema; flavors do not override it.
+    #
+    # @return [String]
+    # @raise [Pubid::Errors::InvalidInputError] when the flavor has no
+    #   pubid-scheme schema yet
+    def to_pubid_urn
+      Pubid::PubidUrn.generate(self)
+    end
+
     def resolve_urn_generator
       flavor = self.class.name.split("::")[1]
       Object.const_get("Pubid::#{flavor}::UrnGenerator")

data/lib/pubid/iec/pubid_urn_schema.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    # The pubid-scheme URN of IEC — PARTIAL (issue #656;
+    # docs/URN-SCHEMES.adoc).
+    #
+    # Only +pubid:iec:international-standard+ is declared, because IEEE
+    # identifiers nest it (IEC/IEEE co-publications). IEC's own wave declares
+    # the rest of the flavor; until then IEC stays pending in the contract
+    # spec. The official RFC 5141-style urn:iec:std: form stays on #to_urn.
+    PubidUrnSchema = Pubid::PubidUrn.define("iec") do
+      atom "publisher", "pub"
+      atom "copublishers", "co", kind: :list
+      atom "part", "part"
+      atom "subpart", "subpart"
+      atom "year", "year"
+      atom "month", "month"
+      atom "day", "day"
+      atom "undated", "undated", kind: :bool
+      atom "edition", "ed"
+      atom "stage", "stage"
+      atom "stage_iteration", "iter"
+      atom "database", "database"
+      atom "languages.*.code", "lang"
+
+      facet "languages.*.original_code", "langsrc"
+
+      type "pubid:iec:international-standard", "is"
+    end
+  end
+end

data/lib/pubid/iec.rb

@@ -17,6 +17,7 @@ module Pubid
     autoload :SingleIdentifier, "#{__dir__}/iec/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/iec/supplement_identifier"
     autoload :Parser, "#{__dir__}/iec/parser"
+    autoload :PubidUrnSchema, "#{__dir__}/iec/pubid_urn_schema"
     autoload :Builder, "#{__dir__}/iec/builder"
     autoload :UrnParser, "#{__dir__}/iec/urn_parser"
     autoload :UrnGenerator, "#{__dir__}/iec/urn_generator"

data/lib/pubid/ieee/CLAUDE.md

@@ -99,3 +99,5 @@ The lesson BSI paid for: a wrapper's hand-written `#number` delegation makes the
 - **Joint stage-first forms are lead ISO, and the ISO face is lossless (pubid#477)**: a stage word printed in the ISO position (`IEEE FCD 15026.3:2010`, `IEEE/IEC CD2 P62582-2017-05`) parses as printed (#469): `Builder#build_joint_development` sets `lead_party "ISO"` whatever the publisher order, so `canonical_format` is `:iso`. PR #472 had made the lead the first printed publisher and rendered an IEEE-first form in the `D=` face — but the grammar artifact cannot parse most of those renders (`D=FCD`, `D=CD.2`, a non-P number, a month), and `D=CD-2020` parses into a *different* id (`ieee_draft`, no `iso_stage`), so 19 published `relaton-data-ieee` rows stopped matching themselves. The `D=` face now prints only for an id that carries a `D=` designator, or on an explicit `to_s(format: :ieee)`. `JointDevelopment#to_iso_format` prints `iso_stage` as stored (`DIS2`, `CD4` — #472's bare `CD` lost the iteration) and the date in the spelling that parses back (`#iso_date_suffix`: `:2018`, `-2018-05`, `, April 2019`). **The test is `parse(to_s) == id`, not a stable `to_s`**: a lossy render reaches a fixed point and round-trips its *hash* (`iso_stage_spellings_spec` held both while dropping `CD4`→`CD`), yet the reparse is a different identifier. Measured over the 118 joint stage rows of `relaton-data-ieee`: `to_s` stable 100 → 118, `==` 51 → 106; the other 12 carry an `ieee_draft` or an edition that the ISO face still drops. **PARG separator-in-capture, again (#471)**: the draft `revision` capture is `".12"`, and `Draft#to_s` adds its own dot, so `handle_draft` strips the leading dot (`D2022.10.12` rendered `D2022.10..12`). Check every capture a renderer re-joins with a separator. Locked by `spec/pubid/ieee/joint_stage_roundtrip_spec.rb` (stored index hashes → `parse(to_s) == row`).
 
 - **IEEE parses through the edition-2 artifact's typed model bindings (the last converter wave)**: the three `Backend.parse` sites (`identifiers/base.rb` `parse_single`, `Aiee::Identifier.parse`, `Ire::Identifier.parse`) route through `Pubid::Parg::Model.bound` — the grammar's `bindings` block produces the builder-ready hash at the engine, replacing the tree normalization. The grammar side (pubid-grammar `grammars/{ieee,nesc}.parg` edition 2 + bindings, plus a class-ref inlining pass over the merged `aiee.parg`/`ire.parg`) keeps every capture the builder reads: leaf scalars bind `(string)`; the branch/wrapper captures the builder dispatches on (`draft`, `parameters`, `publishers`, `base`, `relationship_type`, `related_ids`, the aiee/ire/nesc wrappers, …) bind `(raw)` — raw subtrees carry `Parsanol::Slice` leaves whose `to_s`/`==` behave like strings, so `extract_value` and the `.is_a?(Hash)` probes are unchanged. **Load-bearing grammar deviations** (documented in the `.parg` headers): the zero-width markers are re-spelled as real-token captures (`printed_dash_year`/`printed_month_year` capture their branch's leading separator, `iec_label_dash` the dash, `iso_published` the whole joint head choice — every read sits behind a nil-`iso_stage` gate, so the wider presence set is inert exactly where v1's was narrow); the `([dash]) as draft_dash` / `([rev_sep] as rev_sep)` capture-over-OPTIONAL landmines are `[ (x) as y ]` (parsanol-ruby#394); nested-only captures that collide with a top-level name rename with the builder (`draft_date_month/year/day`, `draft_version_dash_*`, `fdraft_month/year`, and `reaffirmed_year` — unbound, because binding it would have surfaced the reaffirmation year v1 kept absent). **Class RULE refs (`digit`/`lower`/`upper`, and multi-char ones like `alnum_char`/`identifier_string`'s `non_nl`) materialize per-token named nodes inside captures when the runtime recompiles the `use`-importing source — the vendored `data/parg/{aiee,ire,nesc}.parg` copies are the live import sources, so they must be re-vendored together with the artifacts** (a stale `.parg` beside a fresh `.json` silently parses through the old grammar). **Builder accommodations** (all dual-key with the v1 spellings as fallback, so HEAD trees and bound maps read alike): the renamed nested keys; and the multi-segment draft-version normalization at the top of `build_single_identifier` — edition-2 trees materialize a "D2.1.1" designator as per-token nodes with no `:draft_version`, where v1 degraded to a whole-clause leaf (reconstructed: the leaf string → `Draft.parse` inverse) or to a date-only hash when a draft date follows (no draft built). **Measured**: fixture-corpus parity (old artifact + tree backend + builder vs new artifact + bound + builder) over all 9,054 pass-fixture inputs → 1 diff, and standalone aiee/ire/nesc sweeps → 0 diffs each. **The one residue is an engine wall, documented not chased**: `IEC/IEEE PC37.60/P62271-111_D6.1` (testsuite case `ieee.project_draft_identifier.0946`, one corpus input, one `draft_compact_convergence` example) — v1's edition-1 tree degraded its whole draft clause ("DP62271-111_D6.1, Aug 2016", two P-numbers plus date) into a single leaf, and edition-2's fully-named trees cannot reproduce that collapse at any binding spelling (isolated rule probes + programmatic branch bisect); the row is one of the two-P-number joint one-offs already recorded as deferred above. The conversion also **fixed** two testsuite rows (`ieee.project_draft_identifier.9263` "ISO/IEC/IEEE P42010.2019/D4" / "P42010.WD4:2019(E)" — the lettered `draft_iso_iteration` capture now binds, so the D= face composes), at the cost of the 0946 residue above.
+
+- **The pubid-scheme URN (`#to_pubid_urn`, issue #656) — IEEE wave.** Schema: `lib/pubid/ieee/pubid_urn_schema.rb`; design and rulings: the `[[urn-ieee]]` section of `docs/URN-SCHEMES.adoc`. All 9,049 parseable pass ids emit, round-trip by `to_hash`, are path-safe and collision-free; the contract row is `spec/pubid/pubid_urn_contract_spec.rb`, the per-family examples `spec/pubid/ieee/pubid_urn_spec.rb`. **No `to_hash` change, so no `relaton-data-ieee` re-crawl.** Three things to know before editing: **(1)** the wrappers whose parent slot is not `base` (`ieee_identifier`, `first_identifier`, `primary_identifier` …, see "The parent slot is never called `base` in IEEE" above) write that document as a nested atom, so they do NOT share its slug prefix — renaming a slot to `base` moves every such URN; **(2)** IEEE nests ANSI and IEC ids, so ANSI landed whole with this wave and `lib/pubid/iec/pubid_urn_schema.rb` is a partial schema for the one IEC type the corpus nests — a new nested foreign type (an adopted `IEC TR`, `TS`, `AMD`, `CSV`) makes `#to_pubid_urn` raise until its flavor's schema declares it; **(3)** the schema must place every `to_hash` key, so a new IEEE attribute fails the contract row until its atom is declared — add it in the shared-vocabulary group it belongs to, never at the end out of habit, because atom order is part of every published slug. **The URN inherits two `to_hash` gaps, pinned rather than fixed**: `csa_identifier` is a plain accessor, so the CSA half of a `CsaDualPublished` is lost (4 corpus ids, and two such documents with the same IEEE half share a hash and a URN); and one `separator` serves every part, so `IEEE Std 7-4.3.2-2016` comes back as `7.4.3.2` (14 ids). A third: `SupplementIdentifier#to_hash` drops the delegated `publisher` only on a top-level wrapper, so for a non-IEEE supplement nested in an adoption (`IEEE Std 1234-2010 (ISO 1234/Amd 1:2001)`) `from_hash(to_hash)` is not idempotent and `parse_urn` refuses the emitted URN as not canonical (none in the corpus). Fixing any of the three changes `to_hash`. Separately, `IEC/IEEE P62582-6, FDIS May 2019` and `ISO/IEC/IEEE P21840, DIS-2019` raise `Parsanol::PARG::BindError` from `parse` — the parse-error contract expects `Pubid::Errors::ParseError`.

data/lib/pubid/ieee/pubid_urn_schema.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    # The pubid-scheme URN of IEEE (issue #656; docs/URN-SCHEMES.adoc).
+    #
+    #   IEEE Std 802.11-2016
+    #   urn:pubid:ieee:std:802:stage-Std:part-11:year-2016:f:0.sep-.
+    #
+    # The core is the document number. Every other value is an optional
+    # prefixed atom, in the order below: the shared vocabulary first (who,
+    # what, which part, when, which edition, which state), then the IEEE
+    # flags, then the identifiers an IEEE id nests.
+    #
+    # The wrappers that name their wrapped document something other than
+    # +base+ (+ieee_identifier+, +first_identifier+, +primary_identifier+ …)
+    # write it as a nested atom, not as a root-first chain node, so they do
+    # not share the slug prefix of that document. Renaming them to +base+
+    # would change #to_hash and needs a relaton-data-ieee re-crawl.
+    #
+    # The official urn:ieee:std: form (RFC 8069) stays on #to_urn.
+    PubidUrnSchema = Pubid::PubidUrn.define("ieee") do
+      # Who.
+      atom "publisher", "pub"
+      atom "publishers", "pubs", kind: :list
+      atom "lead_party", "lead"
+      atom "copublisher", "co", kind: :list
+      atom "copublishers.*.body", "copubs"
+      # What.
+      atom "prefix", "prefix"
+      atom "type", "type"
+      atom "variant", "variant"
+      # Which part.
+      atom "parts", "part", kind: :list
+      atom "part", "pt"
+      atom "subpart", "subpart"
+      # When.
+      atom "year", "year"
+      atom "month", "month"
+      atom "day", "day"
+      atom "date.year", "dateyear"
+      atom "date.month", "datemonth"
+      atom "date.day", "dateday"
+      atom "date.undated", "undated", kind: :bool
+      atom "date_info", "dateinfo"
+      atom "iec_year", "iecyear"
+      # Which edition or revision.
+      atom "edition", "ed"
+      atom "edition_month", "edmonth"
+      atom "revision", "rev"
+      atom "reaffirmed", "reaff"
+      # Which state.
+      atom "stage", "stage"
+      atom "stage_iteration", "iter"
+      atom "iso_stage", "isostage"
+      atom "ieee_draft", "ieeedraft"
+      atom "draft", "draft"
+      atom "draft_info", "draftinfo"
+      atom "draft_status", "draftstatus"
+      atom "typed_stage.abbr", "tsabbr", kind: :list
+      atom "typed_stage.stage_code", "tsstage"
+      atom "typed_stage.type_code", "tstype"
+      atom "typed_stage.iso_stage_equivalent", "tsiso"
+      atom "typed_stage.ieee_draft_equivalent", "tsieee"
+      atom "typed_stage.approval_status", "tsapproval"
+      atom "typed_stage.project_status", "tsproject", kind: :bool
+      # Which language and locality.
+      atom "languages.*.code", "lang"
+      atom "locality.value", "loc"
+      # IEEE flags and free-text designations.
+      atom "project_marker", "project", kind: :bool
+      atom "redline", "redline", kind: :bool
+      atom "interpretation", "interp", kind: :bool
+      atom "registered", "registered", kind: :bool
+      atom "abbr_suffix", "abbrsuffix", kind: :bool
+      atom "abbr_suffix_registered", "abbrsuffixreg", kind: :bool
+      atom "rev_bare", "revbare", kind: :bool
+      atom "space_before_draft", "spacedraft", kind: :bool
+      atom "month_glued", "monthglued", kind: :bool
+      atom "ashrae_number", "ashrae"
+      atom "ashrae_year", "ashraeyear"
+      atom "iso_identifier", "isoid"
+      atom "adoption", "adoption"
+      atom "amendment_to", "amendmentto"
+      atom "crossref", "crossref"
+      atom "nickname", "nick"
+      atom "note", "note"
+      atom "parenthetical_content", "paren"
+      atom "relationships.*.relationship_type", "rel"
+      # Identifiers an IEEE id nests.
+      atom "ieee_identifier", "ieeeid", kind: :id
+      atom "iec_identifier", "iecid", kind: :id
+      atom "first_identifier", "first", kind: :id
+      atom "second_identifier", "second", kind: :id
+      atom "primary_identifier", "primary", kind: :id
+      atom "secondary_identifier", "secondary", kind: :id
+      atom "parenthetical_identifier", "parenid", kind: :id
+      atom "adopted_identifiers", "adopted", kind: :ids
+      atom "revision_of", "revof", kind: :id
+      atom "supplement_to", "supto", kind: :id
+      atom "amendments", "amds", kind: :ids
+      atom "corrigenda", "cors", kind: :ids
+      atom "incorporates", "incl", kind: :ids
+      atom "supersedes", "supersedes", kind: :ids
+
+      # Spelling only.
+      facet "separator", "sep"
+      facet "separators.*", "seps"
+      facet "rev_sep", "revsep"
+      facet "year_sep", "yearsep"
+      facet "date_separator", "datesep"
+      facet "original_format", "format"
+      facet "languages.*.original_code", "langsrc"
+
+      type "pubid:ieee:standard", "std"
+      type "pubid:ieee:project-draft-identifier", "proj"
+      type "pubid:ieee:si-standard", "si"
+      type "pubid:ieee:redlined-standard", "redlined"
+      type "pubid:ieee:joint-development", "joint"
+      type "pubid:ieee:iec-ieee-copublished", "iecieee"
+      type "pubid:ieee:dual-identifier", "dual"
+      type "pubid:ieee:dual-published", "dualpub"
+      type "pubid:ieee:csa-dual-published", "csadual"
+      type "pubid:ieee:multi-numbered-identifier", "multi"
+      type "pubid:ieee:adopted-standard", "adopted"
+      type "pubid:ieee:parenthetical-identifier", "paren"
+
+      type "pubid:ieee:amendment", "amd"
+      type "pubid:ieee:corrigendum", "cor"
+      type "pubid:ieee:interpretation-identifier", "int"
+      type "pubid:ieee:conformance-identifier", "conf"
+      type "pubid:ieee:supplement-identifier", "sup"
+
+      type "pubid:ieee:aiee", "aiee"
+      type "pubid:ieee:ire", "ire"
+
+      type "pubid:ieee:nesc-standard", "nesc"
+      type "pubid:ieee:nesc-edition", "nescedition"
+      type "pubid:ieee:nesc-handbook", "nescbook"
+      type "pubid:ieee:nesc-draft", "nescdraft"
+      type "pubid:ieee:nesc-preprint", "nescpre"
+      type "pubid:ieee:nesc-redline", "nescredline"
+
+      # The base class. The builder makes one for a parenthetical inside a
+      # relationship, whose related ids #to_hash does not serialize today;
+      # declared so that one in any other slot still emits.
+      type "pubid:ieee:identifier", "id"
+    end
+  end
+end

data/lib/pubid/ieee.rb

@@ -18,6 +18,7 @@ module Pubid
     autoload :Ire, "#{__dir__}/ieee/ire"
     autoload :Nesc, "#{__dir__}/ieee/nesc"
     autoload :Parser, "#{__dir__}/ieee/parser"
+    autoload :PubidUrnSchema, "#{__dir__}/ieee/pubid_urn_schema"
     autoload :PreParser, "#{__dir__}/ieee/pre_parser"
     autoload :Compaction, "#{__dir__}/ieee/compaction"
     autoload :ProjectRenderer, "#{__dir__}/ieee/project_renderer"

data/lib/pubid/iso/pubid_urn_schema.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    # The pubid-scheme URN of ISO (issue #656; docs/URN-SCHEMES.adoc).
+    #
+    #   ISO/IEC 13818-1:2015/Amd 3:2016
+    #   urn:pubid:iso:is:13818:co-IEC:part-1:year-2015:amd:3:co-IEC:year-2016
+    #
+    # The type tokens follow the RFC 5141 type codes where one exists. The
+    # core is the document number; every other value is an optional prefixed
+    # atom, in the order below. The official urn:iso:std: form stays on
+    # #to_urn (Pubid::Iso::UrnGenerator).
+    PubidUrnSchema = Pubid::PubidUrn.define("iso") do
+      atom "publisher", "pub"
+      atom "copublishers", "co", kind: :list
+      atom "part", "part"
+      atom "subpart", "subpart"
+      atom "year", "year"
+      atom "month", "month"
+      atom "day", "day"
+      atom "undated", "undated", kind: :bool
+      atom "edition.number", "ed"
+      atom "stage", "stage"
+      atom "stage_iteration", "iter"
+      atom "supplement_version", "v"
+      atom "languages.*.code", "lang"
+      atom "locality.value", "loc"
+
+      facet "languages.*.original_code", "langsrc"
+      facet "edition.original_text", "edsrc"
+
+      type "pubid:iso:international-standard", "is"
+      type "pubid:iso:technical-report", "tr"
+      type "pubid:iso:technical-specification", "ts"
+      type "pubid:iso:guide", "guide"
+      type "pubid:iso:pas", "pas"
+      type "pubid:iso:recommendation", "r"
+      type "pubid:iso:international-standardized-profile", "isp"
+      type "pubid:iso:international-workshop-agreement", "iwa"
+      type "pubid:iso:technology-trends-assessments", "tta"
+      type "pubid:iso:data", "data"
+      type "pubid:iso:tc-document", "tcdoc",
+           atoms: [%w[tc_type tctype], %w[tc_number tc],
+                   %w[sc_type sctype], %w[sc_number sc],
+                   %w[wg_type wgtype], %w[wg_number wg]]
+      type "pubid:iso:directives", "dir", atoms: [%w[subgroup subgroup]]
+      type "pubid:iso:directives-supplement", "dirsup"
+
+      type "pubid:iso:amendment", "amd"
+      type "pubid:iso:corrigendum", "cor"
+      type "pubid:iso:addendum", "add"
+      type "pubid:iso:extract", "ext"
+      type "pubid:iso:supplement", "sup"
+
+      type "pubid:iso:all-parts", "all", atoms: [["identifiers", "ids", :ids]]
+      type "pubid:iso:bundled-identifier", "bundle",
+           atoms: [["supplements", "sups", :ids]]
+    end
+  end
+end

data/lib/pubid/iso.rb

@@ -20,6 +20,7 @@ module Pubid
     autoload :Identifiers, "#{__dir__}/iso/identifiers"
     autoload :Normalizer, "#{__dir__}/iso/normalizer"
     autoload :Parser, "#{__dir__}/iso/parser"
+    autoload :PubidUrnSchema, "#{__dir__}/iso/pubid_urn_schema"
     autoload :RenderingStyle, "#{__dir__}/iso/rendering_style"
     autoload :SingleIdentifier, "#{__dir__}/iso/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/iso/supplement_identifier"

data/lib/pubid/itu/CLAUDE.md

@@ -113,3 +113,18 @@ a replay of all 24,382 rows and every ITU pass fixture showed 0 changes.
   **Not done:** an RR supplement (`ITU-R RR (2020) Amd 1` fails; the
   base-less `ITU-R RR Amd 1` still builds an Amendment on series `RR`), and
   `ITU-R RR-E` is still a Recommendation numbered `E` — both as on `main`.
+
+## pubid-scheme URN (issue #656)
+
+`lib/pubid/itu/pubid_urn_schema.rb` covers all 17 types; design and rulings
+in `docs/URN-SCHEMES.adoc` (`[[urn-itu]]`). **A new rendering flag needs a
+place in that schema, or `#to_pubid_urn` raises for every id that sets it.**
+Declare it as a `:bool` *facet* when it is spelling only (the
+`number_glued`/`series_suffix_spaced` kind — "the same document") and as a
+`:bool` *atom* when it names a different document (`technical`,
+`attachment`, `series_word`). The facet/atom choice is what decides whether
+a slug without its `f` group keeps two ids apart. Not placed today:
+`combined.*.parts` (a list inside a list; no pass fixture has one).
+`imp_marker` (`G.Imp712`) and `common_text_twin` (`| ISO/IEC …`, an `:id`
+atom) are in no pass fixture either; the contract spec reads only `pass/`,
+so sweep `full/` and the spec literals as well after a schema change.