pubid 2.0.8 → 2.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8013a826102b555c7067ce39bb01b1b3a4d43a6ec09ba6092ae4fe80ce364c8e
-  data.tar.gz: 9e7ebbfa50e70911201bc5800438ed661c1d03116c85e7f96f164bfc4089b615
+  metadata.gz: 014b932f4ce8d6a4da07b23e611467dc460afc19aa73f9be3af191cab1007a02
+  data.tar.gz: 284a4f85f2adcdabe735a20c5f427bf15a242c8b660c66d2ebde54f1938a2665
 SHA512:
-  metadata.gz: f3d0739c523091e44a03e9c4796696a046dbbad30b6681cc4d19e69df785fff10a8bfb83912bff0d3215def503a1d28d48e1f1ca5f76335424cf9f7782c672bd
-  data.tar.gz: ae1b998769f90c7ea9463cd11c66f0374bf4598d2c7a425bb2f615c5acf592652f2a98fba9bf3b8c1db5c10d4f7b24952c516ca994de58f2f8c55b17db42919b
+  metadata.gz: bdecc7d28c6b0bc0c2550d9a643e48324f5f40c8feb3faf3e931c6b2928f573f1c07e01db60d30c016fab9e60bca035e4cf9f4b064c9a47a973b1aa5e500cea3
+  data.tar.gz: 112284d94ca1994025773f8de8ba04840e3560fc339a955c07241e1c0def5bae291f7285aef723ee370669cc8682d7ef88a1d1afd21a37d1c2cb2e890bc965eb

data/README.adoc

@@ -93,7 +93,8 @@ id.to_urn  # => "urn:iso:std:iso:9001:amd:2020:v1"
 `#to_urn` follows the registered grammar of the organization, which can
 drop values (RFC 5141 has no year). `#to_pubid_urn` is pubid's own URN: it
 carries every value, always round-trips through `Pubid.parse_urn`, and is
-safe to use as an HTTP path. ISO, IEEE, ANSI, ITU, NIST and ASTM support it now; the other flavors follow
+safe to use as an HTTP path. ISO, IEEE, ANSI, ITU, NIST, ASTM, API, ASHRAE,
+ASME, JCGM, OIML, ETSI, GOST and PLATEAU support it now; the other flavors follow
 (link:docs/URN-SCHEMES.adoc[URN schemes]).
 
 [source,ruby]

data/data/parg/sae.json

@@ -1 +1 @@
-{"bindings":null,"version":"0.1.0","grammar":"PubidSae","shape":"parsanol-tree/v2","binding_version":1,"entries":{"identifier":{"root":"identifier","grammar":{"atoms":[{"Str":{"pattern":"SAE"}},{"Named":{"name":"publisher","atom":0}},{"Entity":{"atom":3}},{"Str":{"pattern":" "}},{"Entity":{"atom":12}},{"Str":{"pattern":"AMS"}},{"Str":{"pattern":"AIR"}},{"Str":{"pattern":"ARP"}},{"Str":{"pattern":"AS"}},{"Str":{"pattern":"J"}},{"Str":{"pattern":"MA"}},{"Alternative":{"atoms":[5,6,7,8,9,10]}},{"Named":{"name":"type","atom":11}},{"Entity":{"atom":3}},{"Repetition":{"atom":13,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":29}},{"Entity":{"atom":17}},{"Re":{"pattern":"[\\x41-\\x5a]"}},{"Repetition":{"atom":16,"min":1,"max":1,"tag":"Repetition"}},{"Entity":{"atom":20}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Repetition":{"atom":19,"min":1,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[18,21]}},{"Entity":{"atom":20}},{"Repetition":{"atom":23,"min":1,"max":null,"tag":"Repetition"}},{"Entity":{"atom":17}},{"Repetition":{"atom":25,"min":0,"max":1,"tag":"Repetition"}},{"Sequence":{"atoms":[24,26]}},{"Alternative":{"atoms":[22,27]}},{"Named":{"name":"number","atom":28}},{"Entity":{"atom":31}},{"Str":{"pattern":":"}},{"Named":{"name":"colon","atom":30}},{"Entity":{"atom":36}},{"Entity":{"atom":20}},{"Repetition":{"atom":34,"min":4,"max":4,"tag":"Repetition"}},{"Named":{"name":"year","atom":35}},{"Sequence":{"atoms":[32,33]}},{"Repetition":{"atom":37,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[1,2,4,14,15,38]}}],"root":39},"bindings":[{"capture":"type","path":"type","type":"string","card":null,"preprocess":null},{"capture":"number","path":"number","type":"string","card":null,"preprocess":null},{"capture":"year","path":"year","type":"string","card":null,"preprocess":null},{"capture":"publisher","path":"publisher","type":"string","card":null,"preprocess":null}]}},"preprocess":{},"tables":{},"lint":{"order_warnings":[]},"default_entry":"identifier","render":{},"derive":{},"tests":[{"entry":"identifier","kind":"accept","input":"SAE J1939","expect":{}},{"entry":"identifier","kind":"accept","input":"SAE AMS2430","expect":{}},{"entry":"identifier","kind":"accept","input":"SAE ARP4754A:2010","expect":{}},{"entry":"identifier","kind":"reject","input":"nonsense","expect":{}}],"docs":{},"source":"# Port of lib/pubid/sae/parser.rb: SAE <AMS|AIR|ARP|AS|J|MA> <number>[:year]\n\ngrammar PubidSae version \"0.1.0\" edition 2 {\n  doc_type = (\"AMS\" / \"AIR\" / \"ARP\" / \"AS\" / \"J\" / \"MA\") as type\n  number = ((1*1letter 1*digit) / (1*digit *1letter)) as number\n  year = (4digit) as year\n  identifier = \"SAE\" as publisher space doc_type [space] number [(colon year)]\n  letter = %x41-5A\n  digit = %x30-39\n  space = \" \"\n  colon = \":\"\n  entry identifier: identifier\n\n  # Typed model bindings: every bound capture lands on the\n  # consumer model's field of the same name.\n  bindings identifier {\n    type -> type (string)\n    number -> number (string)\n    year -> year (string)\n    publisher -> publisher (string)\n  }\n\n\n  test {\n    accept \"SAE J1939\"\n    accept \"SAE AMS2430\"\n    accept \"SAE ARP4754A:2010\"\n    reject \"nonsense\"\n  }\n}\n","source_hash":"2d3a161caeb9c059ce2600050b823aea373712c16cfa662e5f82166c6f7ee01a","unicode_tables":"onigmo (Ruby 3.4.8)","compiler_version":"1.3.114","edition":2,"checksum":"sha256:cdcc10602aa864cbccccd23ab6baaeed8e7edc4e4a8075c6c7a8f90324d7b5e1"}
+{"bindings":null,"version":"0.2.0","grammar":"PubidSae","shape":"parsanol-tree/v2","binding_version":1,"entries":{"identifier":{"root":"identifier","grammar":{"atoms":[{"Str":{"pattern":"SAE"}},{"Named":{"name":"publisher","atom":0}},{"Entity":{"atom":3}},{"Str":{"pattern":" "}},{"Entity":{"atom":86}},{"Str":{"pattern":"AMS-QQ-A"}},{"Str":{"pattern":"AMS-QQ-C"}},{"Str":{"pattern":"AMS-QQ-N"}},{"Str":{"pattern":"AMS-QQ-P"}},{"Str":{"pattern":"AMS-QQ-S"}},{"Str":{"pattern":"AMS-QQ-W"}},{"Str":{"pattern":"AMS-WW-T"}},{"Str":{"pattern":"GEIA-STD"}},{"Str":{"pattern":"AMS-DTL"}},{"Str":{"pattern":"AMS-PRF"}},{"Str":{"pattern":"AMS-STD"}},{"Str":{"pattern":"EIA-STD"}},{"Str":{"pattern":"GEIA-HB"}},{"Str":{"pattern":"GEIA-OP"}},{"Str":{"pattern":"GEIA-TB"}},{"Str":{"pattern":"GEIASTD"}},{"Str":{"pattern":"AMSDTL"}},{"Str":{"pattern":"AMSPRF"}},{"Str":{"pattern":"AMSQQA"}},{"Str":{"pattern":"AMSQQC"}},{"Str":{"pattern":"AMSQQN"}},{"Str":{"pattern":"AMSQQP"}},{"Str":{"pattern":"AMSQQS"}},{"Str":{"pattern":"AMSQQW"}},{"Str":{"pattern":"AMSSTD"}},{"Str":{"pattern":"AMSWWT"}},{"Str":{"pattern":"EIA-IS"}},{"Str":{"pattern":"EIASTD"}},{"Str":{"pattern":"GEIAHB"}},{"Str":{"pattern":"GEIAOP"}},{"Str":{"pattern":"GEIATB"}},{"Str":{"pattern":"AMS-A"}},{"Str":{"pattern":"AMS-B"}},{"Str":{"pattern":"AMS-C"}},{"Str":{"pattern":"AMS-D"}},{"Str":{"pattern":"AMS-F"}},{"Str":{"pattern":"AMS-G"}},{"Str":{"pattern":"AMS-H"}},{"Str":{"pattern":"AMS-I"}},{"Str":{"pattern":"AMS-L"}},{"Str":{"pattern":"AMS-M"}},{"Str":{"pattern":"AMS-P"}},{"Str":{"pattern":"AMS-R"}},{"Str":{"pattern":"AMS-S"}},{"Str":{"pattern":"AMS-T"}},{"Str":{"pattern":"AMS-W"}},{"Str":{"pattern":"EIAIS"}},{"Str":{"pattern":"USCAR"}},{"Str":{"pattern":"AMSA"}},{"Str":{"pattern":"AMSB"}},{"Str":{"pattern":"AMSC"}},{"Str":{"pattern":"AMSD"}},{"Str":{"pattern":"AMSF"}},{"Str":{"pattern":"AMSG"}},{"Str":{"pattern":"AMSH"}},{"Str":{"pattern":"AMSI"}},{"Str":{"pattern":"AMSL"}},{"Str":{"pattern":"AMSM"}},{"Str":{"pattern":"AMSP"}},{"Str":{"pattern":"AMSR"}},{"Str":{"pattern":"AMSS"}},{"Str":{"pattern":"AMST"}},{"Str":{"pattern":"AMSW"}},{"Str":{"pattern":"GEIA"}},{"Str":{"pattern":"AIR"}},{"Str":{"pattern":"AMS"}},{"Str":{"pattern":"ARD"}},{"Str":{"pattern":"ARP"}},{"Str":{"pattern":"CMB"}},{"Str":{"pattern":"CRP"}},{"Str":{"pattern":"EIA"}},{"Str":{"pattern":"MAM"}},{"Str":{"pattern":"MAP"}},{"Str":{"pattern":"SSB"}},{"Str":{"pattern":"TSB"}},{"Str":{"pattern":"AS"}},{"Str":{"pattern":"JA"}},{"Str":{"pattern":"MA"}},{"Str":{"pattern":"MS"}},{"Str":{"pattern":"J"}},{"Alternative":{"atoms":[5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84]}},{"Named":{"name":"type","atom":85}},{"Entity":{"atom":90}},{"Entity":{"atom":3}},{"Str":{"pattern":"-"}},{"Alternative":{"atoms":[88,89]}},{"Named":{"name":"type_sep","atom":87}},{"Repetition":{"atom":91,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":97}},{"Entity":{"atom":95}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Repetition":{"atom":94,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"number","atom":96}},{"Entity":{"atom":107}},{"Str":{"pattern":"-"}},{"Str":{"pattern":"_"}},{"Alternative":{"atoms":[99,100]}},{"Entity":{"atom":95}},{"Repetition":{"atom":102,"min":1,"max":3,"tag":"Repetition"}},{"Named":{"name":"dash","atom":103}},{"Entity":{"atom":95}},{"Lookahead":{"atom":105,"positive":false}},{"Sequence":{"atoms":[101,104,106]}},{"Repetition":{"atom":98,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":113}},{"Entity":{"atom":111}},{"Re":{"pattern":"[\\x41-\\x5a]"}},{"Repetition":{"atom":110,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"tail","atom":112}},{"Repetition":{"atom":109,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":130}},{"Str":{"pattern":"/"}},{"Entity":{"atom":111}},{"Repetition":{"atom":117,"min":0,"max":null,"tag":"Repetition"}},{"Entity":{"atom":95}},{"Repetition":{"atom":119,"min":1,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[118,120]}},{"Entity":{"atom":111}},{"Repetition":{"atom":122,"min":1,"max":null,"tag":"Repetition"}},{"Alternative":{"atoms":[121,123]}},{"Named":{"name":"part","atom":124}},{"Entity":{"atom":111}},{"Repetition":{"atom":126,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"part_tail","atom":127}},{"Repetition":{"atom":128,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[116,125,129]}},{"Repetition":{"atom":115,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":137}},{"Str":{"pattern":"_A"}},{"Entity":{"atom":95}},{"Repetition":{"atom":134,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"amendment","atom":135}},{"Sequence":{"atoms":[133,136]}},{"Repetition":{"atom":132,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":153}},{"Str":{"pattern":":"}},{"Entity":{"atom":95}},{"Repetition":{"atom":141,"min":4,"max":4,"tag":"Repetition"}},{"Named":{"name":"year","atom":142}},{"Sequence":{"atoms":[140,143]}},{"Str":{"pattern":"_"}},{"Entity":{"atom":95}},{"Repetition":{"atom":146,"min":4,"max":4,"tag":"Repetition"}},{"Named":{"name":"year","atom":147}},{"Entity":{"atom":95}},{"Repetition":{"atom":149,"min":2,"max":2,"tag":"Repetition"}},{"Named":{"name":"month","atom":150}},{"Sequence":{"atoms":[145,148,151]}},{"Alternative":{"atoms":[144,152]}},{"Repetition":{"atom":139,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[1,2,4,92,93,108,114,131,138,154]}}],"root":155},"bindings":[{"capture":"publisher","path":"publisher","type":"string","card":null,"preprocess":null},{"capture":"type","path":"type","type":"string","card":null,"preprocess":null},{"capture":"number","path":"number","type":"string","card":null,"preprocess":null},{"capture":"dash","path":"dash","type":"string","card":null,"preprocess":null},{"capture":"tail","path":"tail","type":"string","card":null,"preprocess":null},{"capture":"part","path":"part","type":"string","card":null,"preprocess":null},{"capture":"part_tail","path":"part_tail","type":"string","card":null,"preprocess":null},{"capture":"amendment","path":"amendment","type":"string","card":null,"preprocess":null},{"capture":"year","path":"year","type":"string","card":null,"preprocess":null},{"capture":"month","path":"month","type":"string","card":null,"preprocess":null}]}},"preprocess":{},"tables":{},"lint":{"order_warnings":[]},"default_entry":"identifier","render":{},"derive":{},"tests":[{"entry":"identifier","kind":"accept","input":"SAE J1939","expect":{}},{"entry":"identifier","kind":"accept","input":"SAE J 3016","expect":{}},{"entry":"identifier","kind":"accept","input":"SAE AMS2430","expect":{}},{"entry":"identifier","kind":"accept","input":"SAE ARP4754A:2010","expect":{}},{"entry":"identifier","kind":"accept","input":"SAE AMS-QQ-A-250/4B","expect":{}},{"entry":"identifier","kind":"accept","input":"SAE AMSQQA250/4B","expect":{}},{"entry":"identifier","kind":"reject","input":"nonsense","expect":{}},{"entry":"identifier","kind":"reject","input":"SAE J3016_2021","expect":{}},{"entry":"identifier","kind":"reject","input":"SAE XYZ1","expect":{}},{"entry":"identifier","kind":"example","input":"SAE J3016_202104","expect":{"type":"J","number":"3016","year":"2021","month":"04"}},{"entry":"identifier","kind":"example","input":"SAE AMS4121J","expect":{"type":"AMS","number":"4121","tail":"J"}},{"entry":"identifier","kind":"example","input":"SAE AS22520/45A","expect":{"type":"AS","number":"22520","part":"45","part_tail":"A"}},{"entry":"identifier","kind":"example","input":"SAE AMS5622/H1025","expect":{"type":"AMS","number":"5622","part":"H1025"}},{"entry":"identifier","kind":"example","input":"SAE J2945/AS","expect":{"type":"J","number":"2945","part":"AS"}},{"entry":"identifier","kind":"example","input":"SAE J1939-71:2020","expect":{"type":"J","number":"1939","dash":"71","year":"2020"}},{"entry":"identifier","kind":"example","input":"SAE EIA649_1A","expect":{"type":"EIA","number":"649","dash":"1","tail":"A"}},{"entry":"identifier","kind":"example","input":"SAE AS5259/7A_A1","expect":{"type":"AS","number":"5259","part":"7","part_tail":"A","amendment":"1"}},{"entry":"identifier","kind":"example","input":"SAE AMSSTD595","expect":{"type":"AMSSTD","number":"595"}},{"entry":"identifier","kind":"example","input":"SAE GEIA-STD-0001","expect":{"type":"GEIA-STD","number":"0001"}}],"docs":{},"source":"# SAE identifiers, in SAE's printed form and in the hyphen-free form of its\n# Crossref DOI suffixes (10.4271/<code>):\n#\n#   SAE <type>[ |-]<number>[-<dash>][<tail>][/<part>[<part_tail>]][_A<n>][:yyyy|_yyyymm]\n#\n# The grammar only segments. What a letter tail means (a revision, the\n# metric M of a J report, a digital-annex DA) and which spelling of the type\n# is printed is decided by pubid's lib/pubid/sae/builder.rb, which owns the\n# type table (Pubid::Sae::Components::Type::TYPES). The doc_type\n# alternatives are that table's keys plus their hyphen-free spellings,\n# longest first: PEG commits to the first alternative that matches, so\n# \"AMS\" must come after every \"AMS...\" family.\n\ngrammar PubidSae version \"0.2.0\" edition 2 {\n  doc_type = (\"AMS-QQ-A\" / \"AMS-QQ-C\" / \"AMS-QQ-N\" / \"AMS-QQ-P\" / \"AMS-QQ-S\" / \"AMS-QQ-W\" / \"AMS-WW-T\" / \"GEIA-STD\" / \"AMS-DTL\" / \"AMS-PRF\" / \"AMS-STD\" / \"EIA-STD\" / \"GEIA-HB\" / \"GEIA-OP\" / \"GEIA-TB\" / \"GEIASTD\" / \"AMSDTL\" / \"AMSPRF\" / \"AMSQQA\" / \"AMSQQC\" / \"AMSQQN\" / \"AMSQQP\" / \"AMSQQS\" / \"AMSQQW\" / \"AMSSTD\" / \"AMSWWT\" / \"EIA-IS\" / \"EIASTD\" / \"GEIAHB\" / \"GEIAOP\" / \"GEIATB\" / \"AMS-A\" / \"AMS-B\" / \"AMS-C\" / \"AMS-D\" / \"AMS-F\" / \"AMS-G\" / \"AMS-H\" / \"AMS-I\" / \"AMS-L\" / \"AMS-M\" / \"AMS-P\" / \"AMS-R\" / \"AMS-S\" / \"AMS-T\" / \"AMS-W\" / \"EIAIS\" / \"USCAR\" / \"AMSA\" / \"AMSB\" / \"AMSC\" / \"AMSD\" / \"AMSF\" / \"AMSG\" / \"AMSH\" / \"AMSI\" / \"AMSL\" / \"AMSM\" / \"AMSP\" / \"AMSR\" / \"AMSS\" / \"AMST\" / \"AMSW\" / \"GEIA\" / \"AIR\" / \"AMS\" / \"ARD\" / \"ARP\" / \"CMB\" / \"CRP\" / \"EIA\" / \"MAM\" / \"MAP\" / \"SSB\" / \"TSB\" / \"AS\" / \"JA\" / \"MA\" / \"MS\" / \"J\") as type\n  type_sep = space / \"-\"\n  number = (1*digit) as number\n  # A dash number: J1939-71, EIA649-2, and the DOI's EIA649_1. At most three\n  # digits and no digit after, so \"_202104\" stays a date.\n  dash = (\"-\" / \"_\") (1*3digit) as dash !digit\n  tail = (1*letter) as tail\n  part = \"/\" ((*letter 1*digit) / 1*letter) as part [(1*letter) as part_tail]\n  amendment = \"_A\" (1*digit) as amendment\n  date = (\":\" (4digit) as year) / (\"_\" (4digit) as year (2digit) as month)\n  identifier = \"SAE\" as publisher space doc_type [type_sep] number [dash] [tail] [part] [amendment] [date]\n  letter = %x41-5A\n  digit = %x30-39\n  space = \" \"\n  entry identifier: identifier\n\n  bindings identifier {\n    publisher -> publisher (string)\n    type -> type (string)\n    number -> number (string)\n    dash -> dash (string)\n    tail -> tail (string)\n    part -> part (string)\n    part_tail -> part_tail (string)\n    amendment -> amendment (string)\n    year -> year (string)\n    month -> month (string)\n  }\n\n  test {\n    accept \"SAE J1939\"\n    accept \"SAE J 3016\"\n    accept \"SAE AMS2430\"\n    accept \"SAE ARP4754A:2010\"\n    accept \"SAE AMS-QQ-A-250/4B\"\n    accept \"SAE AMSQQA250/4B\"\n    reject \"nonsense\"\n    reject \"SAE J3016_2021\"\n    reject \"SAE XYZ1\"\n    example \"SAE J3016_202104\" { type: \"J\", number: \"3016\", year: \"2021\", month: \"04\" }\n    example \"SAE AMS4121J\" { type: \"AMS\", number: \"4121\", tail: \"J\" }\n    example \"SAE AS22520/45A\" { type: \"AS\", number: \"22520\", part: \"45\", part_tail: \"A\" }\n    example \"SAE AMS5622/H1025\" { type: \"AMS\", number: \"5622\", part: \"H1025\" }\n    example \"SAE J2945/AS\" { type: \"J\", number: \"2945\", part: \"AS\" }\n    example \"SAE J1939-71:2020\" { type: \"J\", number: \"1939\", dash: \"71\", year: \"2020\" }\n    example \"SAE EIA649_1A\" { type: \"EIA\", number: \"649\", dash: \"1\", tail: \"A\" }\n    example \"SAE AS5259/7A_A1\" { type: \"AS\", number: \"5259\", part: \"7\", part_tail: \"A\", amendment: \"1\" }\n    example \"SAE AMSSTD595\" { type: \"AMSSTD\", number: \"595\" }\n    example \"SAE GEIA-STD-0001\" { type: \"GEIA-STD\", number: \"0001\" }\n  }\n}\n","source_hash":"204b7183faedf1026e76016e92d3e9904d81930ed04d7a9d54849ac78f1ad6e7","unicode_tables":"onigmo (Ruby 3.4.10)","compiler_version":"1.3.129","edition":2,"semantics_hash":"sha256:58d95b3087380a9ddb6598898095eac06e5cf639bc63d699c0db8d51c88c15f0","checksum":"sha256:ea9c116c71abfbf523abb94e20bede94a0b9613621dd2d4cae1990aad6f3e774"}

data/lib/pubid/api/pubid_urn_schema.rb

@@ -12,6 +12,8 @@ module Pubid
       atom "part", "part"
       atom "section", "section"
       atom "subsection", "subsection"
+      # typeless standards date themselves ("API 650:2020")
+      atom "year", "year"
 
       type "pubid:api:base", "base"
       type "pubid:api:bulletin", "bulletin"

data/lib/pubid/cen_cenelec/CLAUDE.md

@@ -57,3 +57,20 @@ keeps `#matches?(other, ignore:)`.
   decision, on the reading that a published norm should carry a published
   stage by default. It is fixed at the matching layer instead: no grammar
   change, no index re-crawl.
+
+## `locate_type` and `CenelecHarmonizationDocument`
+
+`CenCenelec.locate_type` returns the **first** class in `identifier_types`
+whose `type[:key]` matches, and `identifier_types` reads
+`Identifiers.constants`, whose order Ruby does not guarantee.
+`CenelecHarmonizationDocument` shared the key `:hd` with
+`HarmonizationDocument`, and its autoload was misspelled
+(`CENelecHarmonizationDocument`), so it joined the list only when something
+else had loaded its file before the list was memoized. Then `HD 123:2020`
+could build the CENELEC class: 6 CEN examples failed in one spec order only,
+exposed by the pubid-URN GOST wave, not caused by it. The autoload is fixed
+and the class has its own key `:chd` (the token `docs/URN-SCHEMES.adoc`
+gives it); `spec/pubid/cen_cenelec/type_key_spec.rb` loads the class and
+rebuilds the list, so it does not depend on order. **Every type key in a
+flavor must be unique**; ANSI has the same shape (`Standard` and
+`AmericanNationalStandard` both declare `ans`) and is not checked here.

data/lib/pubid/cen_cenelec/identifiers/cenelec_harmonization_document.rb

@@ -19,8 +19,11 @@ module Pubid
           ),
         ].freeze
 
+        # Its own key: CenCenelec.locate_type returns the first class with
+        # a matching key, and HarmonizationDocument owns :hd ("HD 123:2020").
+        # A shared key made the class choice depend on load order.
         def self.type
-          { key: :hd, title: "CENELEC Harmonization Document", short: "HD" }
+          { key: :chd, title: "CENELEC Harmonization Document", short: "HD" }
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers.rb

@@ -7,7 +7,7 @@ module Pubid
                "#{__dir__}/identifiers/adopted_european_norm"
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
       autoload :Base, "#{__dir__}/identifiers/base"
-      autoload :CENelecHarmonizationDocument,
+      autoload :CenelecHarmonizationDocument,
                "#{__dir__}/identifiers/cenelec_harmonization_document"
       autoload :CenReport, "#{__dir__}/identifiers/cen_report"
       autoload :CenWorkshopAgreement,

data/lib/pubid/cen_cenelec/pubid_urn_schema.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    # The pubid-scheme URN of CEN/CENELEC — PARTIAL (issue #656;
+    # docs/URN-SCHEMES.adoc).
+    #
+    # Only the types a GOST adoption can name are declared: an EN, an
+    # adopted EN ("EN ISO 12100:2010", no number of its own), its amendment
+    # and corrigendum, a CEN TS or TR, and the consolidated
+    # "EN 14988:2017+A1:2020". The atoms keep the doc's canonical order; an
+    # absent atom writes nothing, so the CEN wave can add types and atoms
+    # without changing these URNs. Until then cen_cenelec stays pending in
+    # the contract spec.
+    PubidUrnSchema = Pubid::PubidUrn.define("cencenelec") do
+      atom "publisher", "pub"
+      atom "copublishers", "co", kind: :list
+      atom "part", "part"
+      atom "year", "year"
+      atom "month", "month"
+      atom "version", "v"
+      atom "stage", "stage"
+      atom "adopted", "adopted", kind: :id
+      atom "identifiers", "ids", kind: :ids
+
+      type "pubid:cencenelec:adopted-european-norm", "aen", core: []
+      type "pubid:cencenelec:amendment", "amd"
+      type "pubid:cencenelec:consolidated-identifier", "consol", core: []
+      type "pubid:cencenelec:corrigendum", "cor"
+      type "pubid:cencenelec:european-norm", "en"
+      type "pubid:cencenelec:technical-report", "tr"
+      type "pubid:cencenelec:technical-specification", "ts"
+    end
+  end
+end

data/lib/pubid/cen_cenelec.rb

@@ -19,6 +19,7 @@ module Pubid
     autoload :Identifier, "#{__dir__}/cen_cenelec/identifier"
     autoload :Identifiers, "#{__dir__}/cen_cenelec/identifiers"
     autoload :Parser, "#{__dir__}/cen_cenelec/parser"
+    autoload :PubidUrnSchema, "#{__dir__}/cen_cenelec/pubid_urn_schema"
     autoload :Renderer, "#{__dir__}/cen_cenelec/renderer"
     autoload :SingleIdentifier, "#{__dir__}/cen_cenelec/single_identifier"
     autoload :UrnGenerator, "#{__dir__}/cen_cenelec/urn_generator"

data/lib/pubid/etsi/CLAUDE.md

@@ -32,3 +32,12 @@ keeps `#matches?(other, ignore:)`.
 - `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.
+
+## pubid-scheme URN (issue #656)
+
+`lib/pubid/etsi/pubid_urn_schema.rb`; rulings in `docs/URN-SCHEMES.adoc`
+(`[[urn-etsi]]`). A supplement's `number` is an Integer ordinal, so its core
+is `:int` (`core: [["number", :int]]`), and the codec refuses a String there.
+`minor` and `day` are placed although no pass fixture sets them, because
+`EtsiStandard`'s `key_value` block maps them: a schema must place every key
+the mapping can write, not only the keys the corpus shows.

data/lib/pubid/etsi/pubid_urn_schema.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    # The pubid-scheme URN of ETSI (issue #656; docs/URN-SCHEMES.adoc).
+    #
+    #   ETSI EN 300 175-1 V2.9.1 (2022-01)
+    #   urn:pubid:etsi:es:300~20175:type-EN:part-1:year-2022:month-01:v-2.9.1
+    #
+    #   ETSI ETR 108/A1 ed.1 (1995-08)
+    #   urn:pubid:etsi:es:108:type-ETR:year-1995:month-08:v-1:isedition-true:
+    #     amd:1
+    #
+    # The number is the core of every type. A supplement's number is its
+    # Integer ordinal, so it is an :int core; the document it supplements
+    # comes first, along +base+. The official urn:etsi: form (RFC 8515)
+    # stays on #to_urn.
+    PubidUrnSchema = Pubid::PubidUrn.define("etsi") do
+      atom "type", "type"
+      atom "parts", "part", kind: :list
+      atom "minor", "minor"
+      atom "year", "year"
+      atom "month", "month"
+      atom "day", "day"
+      atom "version", "v"
+      atom "is_edition", "isedition", kind: :bool
+
+      supplement = [["number", :int]]
+      type "pubid:etsi:amendment", "amd", core: supplement
+      type "pubid:etsi:corrigendum", "cor", core: supplement
+      type "pubid:etsi:etsi-standard", "es"
+      type "pubid:etsi:identifier", "id"
+      type "pubid:etsi:supplement-identifier", "si", core: supplement
+    end
+  end
+end

data/lib/pubid/etsi.rb

@@ -17,6 +17,7 @@ module Pubid
     autoload :Identifier, "#{__dir__}/etsi/identifiers/base"
     autoload :Identifiers, "#{__dir__}/etsi/identifiers"
     autoload :Parser, "#{__dir__}/etsi/parser"
+    autoload :PubidUrnSchema, "#{__dir__}/etsi/pubid_urn_schema"
     autoload :Renderer, "#{__dir__}/etsi/renderer"
     autoload :UrnGenerator, "#{__dir__}/etsi/urn_generator"
     autoload :UrnParser, "#{__dir__}/etsi/urn_parser"

data/lib/pubid/gost/CLAUDE.md

@@ -62,3 +62,15 @@ 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.
+
+## pubid-scheme URN (issue #656)
+
+`lib/pubid/gost/pubid_urn_schema.rb`; rulings in `docs/URN-SCHEMES.adoc`
+(`[[urn-gost]]`). The adopted documents nest with their own flavor's schema,
+so this wave added a partial `lib/pubid/cen_cenelec/pubid_urn_schema.rb`.
+**Open gap:** `ForeignReference#raw` is not mapped in `key_value`, so
+`to_hash` drops the text of an adopted document of an unknown flavor
+(`(OECD 460:2017)`): two such adoptions share one hash and one URN, and
+`from_hash` loses the parenthesis. Mapping `raw` changes `to_hash`, and the
+`pubid-testsuite` GOST cases store the hash without it, so the fix must land
+together with a testsuite update. The schema's `raw-` atom is ready for it.

data/lib/pubid/gost/pubid_urn_schema.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gost
+    # The pubid-scheme URN of GOST (issue #656; docs/URN-SCHEMES.adoc).
+    #
+    #   ГОСТ ISO 6848  ->  urn:pubid:gost:is:6848:co-ISO
+    #
+    #   ГОСТ Р 58904-2020/ISO/TR 25901-1:2016
+    #   urn:pubid:gost:ns:58904:year-2020:ia:58904:year-2020:
+    #     adopted-(iso:tr:25901:part-1:year-2016)
+    #
+    # A harmonized or identical adoption wraps the GOST standard in +base+
+    # (written first) and repeats its number and year, as #to_hash does.
+    # The adopted documents are nested with their own flavor's schema
+    # (cencenelec, iec, iso, ieee, astm).
+    PubidUrnSchema = Pubid::PubidUrn.define("gost") do
+      atom "publisher", "pub"
+      atom "copublisher", "co"
+      atom "year", "year"
+      atom "subtype", "subtype"
+      atom "raw", "raw"
+      atom "adopted_identifiers", "adoptedidentifiers", kind: :ids
+      atom "adopted", "adopted", kind: :id
+
+      type "pubid:gost:foreign-reference", "fr"
+      type "pubid:gost:harmonized", "h"
+      type "pubid:gost:identical-adoption", "ia"
+      type "pubid:gost:identifier", "id"
+      type "pubid:gost:interstate-standard", "is"
+      type "pubid:gost:national-standard", "ns"
+    end
+  end
+end

data/lib/pubid/gost.rb

@@ -14,6 +14,7 @@ module Pubid
     autoload :Identifier,   "#{__dir__}/gost/identifier"
     autoload :Identifiers,  "#{__dir__}/gost/identifiers"
     autoload :Parser,       "#{__dir__}/gost/parser"
+    autoload :PubidUrnSchema, "#{__dir__}/gost/pubid_urn_schema"
     autoload :Renderer,     "#{__dir__}/gost/renderer"
     autoload :UrnGenerator, "#{__dir__}/gost/urn_generator"
     autoload :UrnParser,    "#{__dir__}/gost/urn_parser"

data/lib/pubid/identifier.rb

@@ -1468,7 +1468,13 @@ module Pubid
       @hash ||= compute_hash
     end
 
-    def eql?(other)
+    # The second parameter is lutaml's: ComparableModel#== (an alias of its
+    # #eql?(other, compared_objects = {})) recurses with two arguments when
+    # an attribute holds a model of the SAME class, such as the standard
+    # an IEEE "Revision of" id revises. A one-parameter override made #==
+    # raise ArgumentError there. The cycle guard is lutaml's; this method
+    # keeps its own semantics and does not need it.
+    def eql?(other, _compared_objects = nil)
       return false unless other.is_a?(self.class)
 
       hash == other.hash && self == other

data/lib/pubid/iec/pubid_urn_schema.rb

@@ -5,10 +5,12 @@ module Pubid
     # 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.
+    # Only the types other flavors nest are declared: the International
+    # Standard (IEC/IEEE co-publications, GOST adoptions), and the TS, TR,
+    # amendment and consolidated identifier a GOST adoption can name
+    # ("IEC 60079-0:2017+AMD1:2020"). 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
@@ -23,10 +25,15 @@ module Pubid
       atom "stage_iteration", "iter"
       atom "database", "database"
       atom "languages.*.code", "lang"
+      atom "identifiers", "ids", kind: :ids
 
       facet "languages.*.original_code", "langsrc"
 
+      type "pubid:iec:amendment", "amd"
+      type "pubid:iec:consolidated-identifier", "consol", core: []
       type "pubid:iec:international-standard", "is"
+      type "pubid:iec:technical-report", "tr"
+      type "pubid:iec:technical-specification", "ts"
     end
   end
 end

data/lib/pubid/plateau/CLAUDE.md

@@ -0,0 +1,13 @@
+# PLATEAU flavor notes
+
+Read this before you change `lib/pubid/plateau/` or `spec/pubid/plateau/`. The
+root `CLAUDE.md` keeps the cross-flavor contract that every flavor obeys.
+
+## pubid-scheme URN (issue #656)
+
+`lib/pubid/plateau/pubid_urn_schema.rb`; rulings in `docs/URN-SCHEMES.adoc`
+(`[[urn-plateau]]`). PLATEAU is the one flavor whose `number` stays an
+Integer, so its core is `:int` (`core: [["number", :int]]`): `#00` is the core
+`0`, and `00` in a URN is not canonical. The Annex type has no `number`; it
+has no core, its document comes first along `base`, and its `letter` is an
+atom. No input makes an Annex today, so the spec builds one by hand.

data/lib/pubid/plateau/pubid_urn_schema.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    # The pubid-scheme URN of PLATEAU (issue #656; docs/URN-SCHEMES.adoc).
+    #
+    #   PLATEAU Handbook #00 第1.0版  ->  urn:pubid:plateau:hb:0:ed-1.0
+    #
+    # PLATEAU keeps +number+ as an Integer (the one flavor the String retype
+    # left out), so it is an :int core. An Annex has no number of its own:
+    # its document comes first, along +base+, and its letter is an atom.
+    PubidUrnSchema = Pubid::PubidUrn.define("plateau") do
+      atom "publisher", "pub"
+      atom "edition", "ed"
+      atom "annex", "annex", kind: :int
+
+      number = [["number", :int]]
+      type "pubid:plateau:annex", "annex", core: [],
+                                           atoms: [%w[letter letter]]
+      type "pubid:plateau:handbook", "hb", core: number
+      type "pubid:plateau:identifier", "id", core: number
+      type "pubid:plateau:technical-report", "tr", core: number
+    end
+  end
+end

data/lib/pubid/plateau.rb

@@ -13,6 +13,7 @@ module Pubid
     autoload :Identifier, "#{__dir__}/plateau/identifiers/base"
     autoload :Identifiers, "#{__dir__}/plateau/identifiers"
     autoload :Parser, "#{__dir__}/plateau/parser"
+    autoload :PubidUrnSchema, "#{__dir__}/plateau/pubid_urn_schema"
     autoload :Renderer, "#{__dir__}/plateau/renderer"
     autoload :SupplementIdentifier, "#{__dir__}/plateau/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/plateau/urn_generator"

data/lib/pubid/pubid_urn/decoder.rb

@@ -62,18 +62,24 @@ module Pubid
       end
 
       def decode_core(tokens, index, node, schema)
-        schema.core.each do |parts|
+        schema.core.each_with_index do |parts, i|
           break if index >= tokens.size
 
           token = tokens[index]
           break if PubidUrn.structural?(token)
 
-          Paths.put(node, parts, Escape.decode(token)) unless token == NULL
+          unless token == NULL
+            Paths.put(node, parts, core_value(token, schema.core_kinds[i]))
+          end
           index += 1
         end
         index
       end
 
+      def core_value(token, kind)
+        kind == :int ? integer(token) : Escape.decode(token)
+      end
+
       def decode_atoms(tokens, index, node, schema)
         last = -1
         while index < tokens.size &&

data/lib/pubid/pubid_urn/encoder.rb

@@ -69,11 +69,23 @@ module Pubid
       def core_segments(node, schema)
         values = schema.core.map { |parts| Paths.take(node, parts) }
         values.pop while !values.empty? && values.last.nil?
-        values.map do |value|
-          value.nil? ? NULL : core_value(value, schema)
+        values.each_with_index.map do |value, i|
+          next NULL if value.nil?
+          next core_integer(value, schema, i) if schema.core_kinds[i] == :int
+
+          core_value(value, schema)
         end
       end
 
+      # A decimal never has the shape of structure, so it needs no escape.
+      def core_integer(value, schema, index)
+        return value.to_s if value.is_a?(Integer)
+
+        raise Errors::InvalidInputError,
+              "#{schema.type} #{schema.core[index].join('.')}: " \
+              "#{value.inspect} is not int"
+      end
+
       # A core value that has the shape of structure (PubidUrn::STRUCTURE)
       # gets its first character escaped.
       def core_value(value, schema)

data/lib/pubid/pubid_urn/schema.rb

@@ -48,13 +48,15 @@ module Pubid
 
     # The URN shape of one concrete identifier type.
     class TypeSchema
-      attr_reader :flavor, :type, :token, :core, :atoms, :facets
+      attr_reader :flavor, :type, :token, :core, :core_kinds, :atoms, :facets
 
+      # +core+ is a list of [path, kind] pairs; kind is :string or :int.
       def initialize(flavor:, type:, token:, core:, atoms:, facets:)
         @flavor = flavor
         @type = type
         @token = token
-        @core = core.map { |path| path.split(".") }.freeze
+        @core = core.map { |path, _| path.split(".") }.freeze
+        @core_kinds = core.map { |_, kind| kind }.freeze
         @atoms = atoms.freeze
         @facets = facets.freeze
         @atom_index = atoms.each_with_index.to_h { |atom, i| [atom.prefix, i] }
@@ -86,6 +88,7 @@ module Pubid
       NAME = /\A[a-z][a-z0-9]*\z/
       KINDS = %i[string list bool bools int id ids].freeze
       FACET_KINDS = %i[string list bool bools].freeze
+      CORE_KINDS = %i[string int].freeze
       # "f" opens the facet group; "type" is the type-metadata URN
       # (Pubid::IdentifierMetadata, "urn:pubid:<flavor>:type:<key>").
       RESERVED_TOKENS = %w[f type].freeze
@@ -110,7 +113,9 @@ module Pubid
 
       # @param type [String] the +_type+ the class serializes
       # @param token [String] the short type token of the URN
-      # @param core [Array<String>] the positional core paths
+      # @param core [Array<String, Array>] the positional core paths; an
+      #   entry is a path (a String value) or [path, kind], kind :string or
+      #   :int
       # @param atoms [Array<Array>] extra atoms: [path, prefix, kind]
       # @param facets [Array<Array>] extra facets: [path, name, kind]
       def type(type, token, core: %w[number], atoms: [], facets: [])
@@ -126,7 +131,8 @@ module Pubid
         check_unique!(all_facets.map(&:name), "facet name", type)
 
         schema = TypeSchema.new(flavor: flavor, type: type, token: token,
-                                core: core, atoms: all_atoms,
+                                core: core.map { |spec| build_core(*spec) },
+                                atoms: all_atoms,
                                 facets: all_facets)
         @types[type] = schema
         @tokens[token] = schema
@@ -142,6 +148,14 @@ module Pubid
 
       private
 
+      def build_core(path, kind = :string)
+        unless CORE_KINDS.include?(kind)
+          raise ArgumentError, "unknown core kind #{kind.inspect}"
+        end
+
+        [path, kind]
+      end
+
       def build_atom(path, prefix, kind = nil)
         check_name!(prefix, "atom prefix")
         Atom.new(path, prefix, check_kind!(path, kind, KINDS, "atom"))

data/lib/pubid/pubid_urn.rb

@@ -106,6 +106,46 @@ module Pubid
         string.is_a?(String) && string.b[0, PREFIX.length].downcase == PREFIX
       end
 
+      # The slug form (relaton#441): the URN wearing HTTP-path clothes.
+      # Each ":" segment becomes a "/" segment, after the "urn:pubid:"
+      # prefix is cut — "urn:pubid:iso:is:9001:year-2015" is
+      # "iso/is/9001/year-2015". The contract's path-safety gate
+      # guarantees no segment carries a "/", so the transform is
+      # bijective: {from_slug} rebuilds the exact URN.
+      #
+      # @param source [Identifier, String] an identifier or its
+      #   pubid-scheme URN
+      # @return [String] the slug, with no leading or trailing "/"
+      # @raise [Errors::InvalidInputError] when a String is not a
+      #   canonical pubid-scheme URN
+      def to_slug(source)
+        urn = source.respond_to?(:to_pubid_urn) ? source.to_pubid_urn : source
+        parse(urn) unless source.respond_to?(:to_pubid_urn)
+        urn.delete_prefix(PREFIX).tr(":", "/")
+      end
+
+      # The slug parse side: "/"-joined segments rebuild the URN and
+      # parse through the canonical gate, so a slug of a landed flavor
+      # round-trips by +to_hash+ exactly like its URN.
+      #
+      # @param string [String] the slug
+      # @return [Identifier]
+      # @raise [Errors::InvalidInputError] when +string+ is not a String
+      #   or is longer than MAX_LENGTH
+      # @raise [Errors::UrnParseError] for a malformed, unknown or
+      #   non-canonical slug
+      def from_slug(string)
+        unless string.is_a?(String)
+          raise Errors::InvalidInputError, Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+        raise Errors::InvalidInputError,
+              "slug exceeds #{MAX_LENGTH} characters" if string.length > MAX_LENGTH
+        raise Errors::UrnParseError, "slug has empty segments" if
+          string.split("/", -1).any?(&:empty?)
+
+        parse("#{PREFIX}#{string.tr('/', ':')}")
+      end
+
       # @return [FlavorSchema, nil]
       def flavor_schema(flavor)
         return @schemas[flavor] if @schemas.key?(flavor)

data/lib/pubid/sae/CLAUDE.md

@@ -0,0 +1,78 @@
+# SAE flavor notes
+
+## Source of the codes: SAE's Crossref deposits
+
+relaton indexes every SAE standard from Crossref (prefix `10.4271`, type
+`standard`). The DOI suffix is SAE's own edition code, lower-case and without
+hyphens: `10.4271/j3016_202104` is `SAE J3016_202104`, `10.4271/amsqqa250_4b`
+is `SAE AMS-QQ-A-250/4B`. relaton upper-cases the suffix and prefixes `SAE `,
+so pubid must read the hyphen-free spelling as well as the printed one.
+
+Measured on the full deposit list (2026-11-04, 47,692 DOIs): **46,726
+parse**, and every parsed code round-trips through `to_s`, `from_hash` and
+the URN, with **0 `to_hash` collisions**. The 966 that do not parse are:
+
+- **791 CP\*** (`CPGM`, `CPFD`, `CPKW`, …): collected-paper products, not
+  standards. Out of scope by decision.
+- **175 one-offs**, none more than 32 of a kind: `SUP1` supplements
+  (`AS4468SUP1A`, `ARP4737SUP1`), language tails (`AS9101F_PTBR`,
+  `IA9137_DEDE`), `J2534-2/10_5_00`, `_4Q2012`, type-less `SAE6857`,
+  `_MMYYYY` dates (`CS1939_042012`, `J2012DA_012013` — the builder's
+  month check refuses the J ones, which would otherwise read as year 120,
+  month 13), `ISO/SAE21434`, `IEEE/EIA12207`, and ~30 families of 1–8
+  documents whose printed form is unknown (`HEB`, `EQB`, `TAHB`, `AMSLP`,
+  `AMSHHG`, …). Add a family by adding it to `Components::Type::TYPES` and
+  re-baking the grammar (below).
+
+## Model
+
+| attribute | example | `===` |
+|---|---|---|
+| `type.abbr` (printed form) | `AMS`, `AMS-QQ-A`, `GEIA-STD` | stated |
+| `number` | `4121`, `0001`, `1939DA`, `174M`, `1939-71` | stated |
+| `part` | `2` of `J2337/2`, `H1025` of `AMS5622/H1025` | strict |
+| `revision` | `J` of `AMS4121J`, `6` of `USCAR2-6` | wildcard |
+| `amendment` | `1` of `AS5259/7A_A1` | strict |
+| `date` (`year`, `month`) | `J3016_202104` | month is a wildcard |
+
+The grammar only segments the code; `builder.rb` decides what each segment
+means, because the meaning depends on the family:
+
+- **A one-letter tail is the revision** (`AMS4121J`, `AS22520/45A`), so every
+  revision of a document shares one `number` bucket and `SAE AMS4121 ===`
+  each of them. relaton then picks the highest revision.
+- **Except the `M` of a J or JA report**, which marks the metric document
+  (`J174M`) and stays in `number`. AMS revisions do reach `M` (`AMS2400M`),
+  so the exception is per family (`Type::METRIC_SUFFIX`).
+- **A longer tail is another document** (`J1939DA` digital annex,
+  `J2735SET`) and stays in `number`, in its own bucket.
+- **A dash number is part of `number`** (`J1939-71`, `EIA649-2`; the DOI
+  writes some of them `_1`: `EIA649_1A` → `EIA-649-1A`). For USCAR the dash
+  is the revision (`USCAR2-6` is USCAR-2 Revision 6, `Type::DASH_REVISION`).
+- **`part` and `amendment` are `subset_strict`**: `SAE J2337` does not match
+  `SAE J2337/2`, and `SAE AS5259/7A` does not match `SAE AS5259/7A_A1`.
+
+Rendering follows SAE: no space after the type (`SAE J3016`, the old
+`SAE J 3016` still parses), a hyphen after a family that kept a military or
+industry series hyphen (`Type::TYPES` holds the separator), `_YYYYMM` when
+the month is known and `:YYYY` otherwise. The amendment tail `_A1` has no
+known printed form and keeps the DOI's.
+
+## The grammar is baked here from a hand-off source
+
+`data/parg/sae.json` was compiled with the pinned parsanol from the source
+recorded in hand-off `pubid__pubid-grammar__sae-crossref-coverage` (the same
+text sits in the artifact's `source` field). Until pubid-grammar lands it,
+`pubid-grammar/grammars/sae.parg` is the OLD grammar, so `parsanol parg
+check` against it reports stale. To change the grammar, extract the source
+(`jq -r .source data/parg/sae.json`), edit, and re-bake:
+
+```bash
+bundle exec parsanol parg compile sae.parg -o data/parg/sae.json
+bundle exec parsanol parg test data/parg/sae.json
+```
+
+The `doc_type` alternatives are the `Type::TYPES` keys plus their
+hyphen-free spellings, longest first (PEG commits to the first match, so
+`AMS` comes after every `AMS…`). `spec/pubid/sae/type_table_spec.rb` fails
+when the two lists drift or an alternative shadows a longer one.

data/lib/pubid/sae/builder.rb

@@ -2,31 +2,109 @@
 
 module Pubid
   module Sae
+    # Builds a Pubid::Sae::Identifier from the grammar's bound captures.
+    #
+    # The grammar only segments the code (data/parg/sae.json):
+    # +type number [dash] [tail] [/part [part_tail]] [_A amendment] [date]+.
+    # The meaning of each segment is decided here, because it depends on the
+    # family:
+    #
+    # * +type+ is stored in its printed form (+AMSQQA+ -> +AMS-QQ-A+).
+    # * A one-letter +tail+ or +part_tail+ is the revision (+AMS4121J+,
+    #   +AS22520/45A+), except the +M+ of a J or JA report, which marks the
+    #   metric document (+J174M+) and stays in the number.
+    # * A longer tail names another document (+J1939DA+, the digital annex;
+    #   +J2735SET+) and stays in the number, so it keeps its own index bucket.
+    # * A +dash+ is a USCAR revision (+USCAR2-6+); in every other family it
+    #   is part of the number (+J1939-71+, +EIA649-2+).
     class Builder < Pubid::Builder::Base
       def self.build(parsed_data)
         new.build(parsed_data)
       end
 
+      def build(data)
+        data = flatten_array(data) if data.is_a?(Array)
+        data = data.transform_keys(&:to_sym)
+        Identifier.new(**attributes_for(data))
+      end
+
       private
 
       def default_identifier_class
         Identifier
       end
 
-      def cast(type, value)
-        case type
-        when :publisher
-          "SAE"
-        when :type
-          Components::Type.new(abbr: value.to_s)
-        when :number
-          value.to_s
-        when :year
-          { date: Components::Date.new(year: value.to_i) }
+      def attributes_for(data)
+        abbr = Components::Type.canonical(data[:type])
+        attrs = { type: Components::Type.new(abbr: abbr),
+                  number: data[:number].to_s }
+        apply_dash(attrs, abbr, data[:dash])
+        apply_tail(attrs, abbr, data[:tail], part: data[:part])
+        apply_part(attrs, data[:part], data[:part_tail])
+        attrs[:amendment] = data[:amendment].to_s if data[:amendment]
+        attrs[:date] = date_for(data) if data[:year]
+        attrs
+      end
+
+      def apply_dash(attrs, abbr, dash)
+        return unless dash
+
+        if Components::Type::DASH_REVISION.include?(abbr)
+          attrs[:revision] = dash.to_s
+        else
+          attrs[:number] += "-#{dash}"
+        end
+      end
+
+      # A one-letter tail before a part (AMS4121J/2) or after a USCAR dash
+      # revision (USCAR2-6A) has no place in the model: no SAE code has that
+      # shape, and storing it in `number` would split the index bucket and
+      # print a string that does not parse back. Such input is refused.
+      def apply_tail(attrs, abbr, tail, part:)
+        return unless tail
+
+        tail = tail.to_s
+        if !revision_letter?(abbr, tail)
+          attrs[:number] += tail
+        elsif part || attrs[:revision]
+          refuse("a revision letter #{tail} before a part or after a " \
+                 "dash revision")
+        else
+          attrs[:revision] = tail
+        end
+      end
+
+      def apply_part(attrs, part, part_tail)
+        return unless part
+
+        attrs[:part] = part.to_s
+        return unless part_tail
+
+        if part_tail.to_s.length == 1
+          attrs[:revision] = part_tail.to_s
         else
-          value
+          attrs[:part] += part_tail.to_s
         end
       end
+
+      def revision_letter?(abbr, tail)
+        return false unless tail.length == 1
+
+        !(tail == "M" && Components::Type::METRIC_SUFFIX.include?(abbr))
+      end
+
+      def date_for(data)
+        month = data[:month]&.to_i
+        refuse("month #{data[:month]}") if month && !(1..12).cover?(month)
+
+        Components::Date.new(year: data[:year].to_i, month: month)
+      end
+
+      def refuse(what)
+        raise Pubid::Errors::ParseError.new(
+          "SAE identifier with #{what} is not supported", nil, flavor: "sae"
+        )
+      end
     end
   end
 end

data/lib/pubid/sae/components/date.rb

@@ -5,12 +5,18 @@ require "lutaml/model"
 module Pubid
   module Sae
     module Components
-      # Date component for SAE standards
-      # SAE uses year only (e.g., 2024, 2022)
+      # The edition date of an SAE document.
+      #
+      # SAE dates a J report by year and month: its edition code is
+      # +J3016_202104+, the April 2021 edition. A reference may state the
+      # year alone (+SAE J3016:2021+); the month is then nil, and nil is a
+      # wildcard under +===+, so the year-only reference matches every
+      # edition of that year.
       class Date < Lutaml::Model::Serializable
         include ::Pubid::SubsetMatch
 
         attribute :year, :integer
+        attribute :month, :integer
 
         def present?
           !year.nil?
@@ -20,8 +26,11 @@ module Pubid
           render
         end
 
+        # +202104+ with a month (SAE's edition code), +2021+ without.
         def render(context: nil)
-          year.to_s
+          return year.to_s unless month
+
+          format("%<year>04d%<month>02d", year: year, month: month)
         end
       end
     end

data/lib/pubid/sae/components/type.rb

@@ -5,13 +5,65 @@ require "lutaml/model"
 module Pubid
   module Sae
     module Components
-      # Type component for SAE document types
-      # AMS, AIR, ARP, AS, MA
+      # The SAE document family: the letters before the number.
+      #
+      # +abbr+ holds the printed form (+AMS-QQ-A+). SAE's DOI suffixes drop
+      # the hyphens (+10.4271/amsqqa250_4b+), so the parser reads both
+      # spellings and the builder stores the printed one (see
+      # +.canonical+).
       class Type < Lutaml::Model::Serializable
         include ::Pubid::SubsetMatch
 
+        # Printed form => the separator SAE prints between it and the number.
+        # A family transferred from a military or industry series keeps that
+        # series' hyphen (+AMS-QQ-A-250+, +GEIA-STD-0001+, +EIA-649+); the
+        # SAE-native families print the number glued (+AMS4121J+, +J3016+).
+        # The grammar's +doc_type+ alternatives list exactly these keys plus
+        # their hyphen-free spellings; +spec/pubid/sae/type_table_spec.rb+
+        # keeps the two in step.
+        TYPES = {
+          "AMS" => "", "AS" => "", "J" => "", "ARP" => "", "AIR" => "",
+          "MA" => "", "MAM" => "", "MAP" => "", "JA" => "", "MS" => "",
+          "ARD" => "", "TSB" => "", "CMB" => "", "SSB" => "",
+          "CRP" => "-", "USCAR" => "-",
+          "EIA" => "-", "EIA-IS" => "-", "EIA-STD" => "-",
+          "GEIA" => "-", "GEIA-STD" => "-", "GEIA-HB" => "-", "GEIA-OP" => "-",
+          "GEIA-TB" => "-",
+          "AMS-STD" => "-", "AMS-DTL" => "-", "AMS-WW-T" => "-",
+          "AMS-QQ-A" => "-", "AMS-QQ-C" => "-", "AMS-QQ-N" => "-",
+          "AMS-QQ-P" => "-", "AMS-QQ-S" => "-", "AMS-QQ-W" => "-",
+          "AMS-PRF" => "-",
+          "AMS-A" => "-", "AMS-B" => "-", "AMS-C" => "-", "AMS-D" => "-",
+          "AMS-F" => "-",
+          "AMS-G" => "-", "AMS-H" => "-", "AMS-I" => "-", "AMS-L" => "-",
+          "AMS-M" => "-", "AMS-P" => "-", "AMS-R" => "-", "AMS-S" => "-",
+          "AMS-T" => "-", "AMS-W" => "-"
+        }.freeze
+
+        # Hyphen-free spelling => printed form.
+        CANONICAL = TYPES.keys.to_h { |abbr| [abbr.delete("-"), abbr] }.freeze
+
+        # The families whose revision is a dash number (+USCAR2-6+ is
+        # USCAR-2 Revision 6), not a letter.
+        DASH_REVISION = %w[USCAR].freeze
+
+        # The families whose trailing +M+ marks the metric edition of a
+        # document (+J174M+), not a revision.
+        METRIC_SUFFIX = %w[J JA].freeze
+
         attribute :abbr, :string
 
+        # @param spelling [String] +AMSQQA+, +AMS-QQ-A+ or +ams-qq-a+
+        # @return [String, nil] the printed form, nil for an unknown family
+        def self.canonical(spelling)
+          CANONICAL[spelling.to_s.upcase.delete("-")]
+        end
+
+        # The separator printed between this family and its number.
+        def separator
+          TYPES.fetch(abbr.to_s, "")
+        end
+
         def to_s
           render
         end

data/lib/pubid/sae/identifiers/base.rb

@@ -4,7 +4,7 @@ module Pubid
   module Sae
     # Base SAE Identifier. Canonical name Pubid::Sae::Identifier. SAE has a single identifier class that IS the
     # document type, so this class is both the base and the only concrete type.
-    # Handles all SAE document types (AMS, AIR, ARP, AS, MA).
+    # Handles every SAE document family (Components::Type::TYPES).
     class Identifier < ::Pubid::Identifier
       def self.parse(input)
         unless input.is_a?(String)
@@ -26,8 +26,19 @@ module Pubid
       # a bare alias of the shared component and never carried more than
       # `value`, so this is a representation change only.
       attribute :number, :string
+      # The revision letter (AMS4121J -> "J"), or USCAR's revision number
+      # (USCAR2-6 -> "6"). Kept out of `number`, so every revision of a
+      # document shares one index bucket and a reference without a revision
+      # matches them all under `===`.
+      attribute :revision, :string
+      # The amendment of a revision: AS5259/7A_A1 -> "1".
+      attribute :amendment, :string
       attribute :date, Sae::Components::Date
 
+      # A part (J2337/2) and an amendment (_A1) are other documents: a
+      # reference without one names the document that has none.
+      subset_strict :part, :amendment
+
       def self.type
         { key: :base, web: :standard, title: "Standard", short: "SAE" }
       end
@@ -44,6 +55,48 @@ module Pubid
       def mr_type
         type&.abbr&.to_s&.downcase
       end
+
+      # The code after the type and its separator, without the date:
+      # "4121J", "22520/45A", "5259/7A_A1", "2-6" (USCAR-2 Revision 6).
+      # The renderer prints it after the type; the URN carries it as one
+      # segment.
+      def designation
+        dash = dash_revision?
+        code = number.to_s
+        code += "-#{revision}" if revision && dash
+        code += "/#{part}" if part
+        code += revision.to_s if revision && !dash
+        code += "_A#{amendment}" if amendment
+        code
+      end
+
+      # A revision after a part (AS22520/45A) is the part document's
+      # revision, so dropping the part drops it too. Without this,
+      # `exclude(:part)` would turn it into revision A of the base document
+      # (AS22520A) and `matches?(other, ignore: [:part])` would pair the two.
+      def exclude(*args)
+        args += [:revision] if part && args.include?(:part)
+        super
+      end
+
+      # A numbered revision of a USCAR family (USCAR-2-6). A letter revision
+      # (USCAR3A) prints glued, as in every other family.
+      def dash_revision?
+        Sae::Components::Type::DASH_REVISION.include?(type&.abbr.to_s) &&
+          revision.to_s.match?(/\A\d+\z/)
+      end
+
+      # Each segment carries a letter, so a dash number (J1939-71 ->
+      # "1939-71") never collides with a part (J1939/71 -> "1939-p71").
+      def mr_number_with_part
+        return nil unless number
+
+        segments = [number]
+        segments << "p#{part}" if part
+        segments << "r#{revision}" if revision
+        segments << "a#{amendment}" if amendment
+        segments.join("-").downcase
+      end
     end
 
   end

data/lib/pubid/sae/renderer.rb

@@ -2,34 +2,31 @@
 
 module Pubid
   module Sae
-    # Human-readable renderer for SAE identifiers.
+    # Human-readable renderer for SAE identifiers, in the form SAE prints:
     #
-    # Produces strings like:
-    #   "SAE AS5553"
-    #   "SAE ARP4754A"
-    #   "SAE AMS2475:2023"
+    #   "SAE J3016"            "SAE AMS4121J"
+    #   "SAE J3016_202104"     "SAE ARP4754A:2010"
+    #   "SAE AS22520/45A"      "SAE AMS-QQ-A-250/4B"
+    #   "SAE AS5259/7A_A1"     "SAE USCAR-2-6"
     #
-    # The renderer is registered as the +:human+ format in the SAE format
-    # registry and invoked via +render(format: :human)+.
+    # A dated edition with a month renders SAE's native edition code
+    # (+_YYYYMM+); a year alone renders +:YYYY+.
     class Renderer < ::Pubid::Renderers::Base
       def render(context: nil, **_opts)
         id = @id
+        type = id.type
+        code = type ? "#{type.abbr}#{type.separator}" : ""
+        result = [id.publisher, code + id.designation].compact.join(" ")
+        result + date_suffix(id, context)
+      end
 
-        parts = []
-
-        # Publisher and type
-        parts << id.publisher if id.publisher
-        parts << id.type.to_s if id.type
-
-        # Number
-        parts << id.number.to_s if id.number
-
-        result = parts.join(" ")
+      private
 
-        # Date
-        result += ":#{id.date.render(context:)}" if id.date
+      def date_suffix(id, context)
+        return "" unless id.date&.year
 
-        result
+        separator = id.date.month ? "_" : ":"
+        "#{separator}#{id.date.render(context:)}"
       end
     end
   end

data/lib/pubid/sae/urn_generator.rb

@@ -2,6 +2,11 @@
 
 module Pubid
   module Sae
+    # urn:sae:{type|std}:{designation}[:{yyyy|yyyymm}]
+    #
+    # The designation is the printed code after the type (Identifier#
+    # designation): "4121J", "22520/45A", "5259/7A_A1". The date segment is
+    # the year, or SAE's year-and-month edition date.
     class UrnGenerator < Pubid::UrnGenerator::Base
       def urn_type
         return "std" unless identifier.type
@@ -12,7 +17,7 @@ module Pubid
       def urn_number
         return nil unless identifier.number
 
-        identifier.number.to_s
+        identifier.designation
       end
 
       def generate

data/lib/pubid/sae/urn_parser.rb

@@ -5,7 +5,7 @@ module Pubid
     # Parses SAE URNs back into identifiers.
     #
     # UrnGenerator emits:
-    #   urn:sae:{type|std}:{number}:{year}
+    #   urn:sae:{type|std}:{designation}[:{yyyy|yyyymm}]
     # where slot[1] is overwritten with the publisher string when a publisher
     # is set. The common single-publisher case keeps slot[1] = "sae".
     #
@@ -25,10 +25,15 @@ module Pubid
 
       private
 
+      # The designation follows the type with no separator; the grammar
+      # reads a glued number for every family. A six-digit date segment is
+      # SAE's year-and-month edition date.
       def build_text(type_token, number, year)
         head = type_token == "std" ? "" : type_token.upcase
-        text = "SAE #{head}#{number}"
-        text += ":#{year}" if year
+        # The designation's letters are upper-case in every SAE code; a URN
+        # that a consumer lower-cased (urn:sae:ams:4121j) still resolves.
+        text = "SAE #{head}#{number.to_s.upcase}"
+        text += "#{year.to_s.length == 6 ? '_' : ':'}#{year}" if year
         text
       end
     end

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.8"
+  VERSION = "2.0.9"
 end

data/lib/pubid.rb

@@ -300,6 +300,26 @@ module Pubid
     urn_parser.parse(string)
   end
 
+  # The slug form (relaton#441): the pubid-scheme URN of +source+ in
+  # HTTP-path clothes — "/"-joined segments after the "urn:pubid:"
+  # prefix ("iso/is/9001/year-2015"). Bijective with
+  # {PubidUrn.from_slug}.
+  #
+  # @param source [Identifier, String] an identifier or its pubid-scheme URN
+  # @return [String]
+  def self.to_slug(source)
+    PubidUrn.to_slug(source)
+  end
+
+  # Parse a slug (see {PubidUrn.from_slug}).
+  #
+  # @param string [String] the slug
+  # @return [Identifier]
+  def self.from_slug(string)
+    eager_load_flavors!
+    PubidUrn.from_slug(string)
+  end
+
   # Parse a pubid-scheme URN, and only that: an official URN such as
   # "urn:iso:std:…" raises. For a consumer that takes a slug and must not
   # accept a lossy official URN by mistake (relaton/relaton#441).

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.8
+  version: 2.0.9
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-04 00:00:00.000000000 Z
+date: 2026-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -361,6 +361,7 @@ files:
 - lib/pubid/cen_cenelec/identifiers/technical_report.rb
 - lib/pubid/cen_cenelec/identifiers/technical_specification.rb
 - lib/pubid/cen_cenelec/parser.rb
+- lib/pubid/cen_cenelec/pubid_urn_schema.rb
 - lib/pubid/cen_cenelec/renderer.rb
 - lib/pubid/cen_cenelec/single_identifier.rb
 - lib/pubid/cen_cenelec/urn_generator.rb
@@ -479,6 +480,7 @@ files:
 - lib/pubid/etsi/identifiers/etsi_standard.rb
 - lib/pubid/etsi/identifiers/supplement_identifier.rb
 - lib/pubid/etsi/parser.rb
+- lib/pubid/etsi/pubid_urn_schema.rb
 - lib/pubid/etsi/renderer.rb
 - lib/pubid/etsi/urn_generator.rb
 - lib/pubid/etsi/urn_parser.rb
@@ -521,6 +523,7 @@ files:
 - lib/pubid/gost/identifiers/interstate_standard.rb
 - lib/pubid/gost/identifiers/national_standard.rb
 - lib/pubid/gost/parser.rb
+- lib/pubid/gost/pubid_urn_schema.rb
 - lib/pubid/gost/renderer.rb
 - lib/pubid/gost/urn_generator.rb
 - lib/pubid/gost/urn_parser.rb
@@ -943,6 +946,7 @@ files:
 - lib/pubid/parsers/urn.rb
 - lib/pubid/pg.rb
 - lib/pubid/plateau.rb
+- lib/pubid/plateau/CLAUDE.md
 - lib/pubid/plateau/builder.rb
 - lib/pubid/plateau/identifier.rb
 - lib/pubid/plateau/identifiers.rb
@@ -951,6 +955,7 @@ files:
 - lib/pubid/plateau/identifiers/handbook.rb
 - lib/pubid/plateau/identifiers/technical_report.rb
 - lib/pubid/plateau/parser.rb
+- lib/pubid/plateau/pubid_urn_schema.rb
 - lib/pubid/plateau/renderer.rb
 - lib/pubid/plateau/supplement_identifier.rb
 - lib/pubid/plateau/urn_generator.rb
@@ -982,6 +987,7 @@ files:
 - lib/pubid/rendering/stage.rb
 - lib/pubid/rendering/supplement.rb
 - lib/pubid/sae.rb
+- lib/pubid/sae/CLAUDE.md
 - lib/pubid/sae/builder.rb
 - lib/pubid/sae/components.rb
 - lib/pubid/sae/components/code.rb