pubid 2.0.19 → 2.0.21

data/lib/pubid/iho/builder.rb

@@ -18,18 +18,34 @@ module Pubid
                       part_edition part_year supplement_edition
                       supplement_year annex_edition annex_year
                       appendix_edition appendix_year volume_edition
-                      volume_year].freeze
+                      volume_year
+                      spec spec_sub spec_variant spec_part
+                      spec_section].freeze
       # The independently-publishable components' own editions; the
       # base edition context is mutually exclusive with them (owner
       # ruling on the two publication modes).
       COMPONENT_EDITIONS = %i[part_edition supplement_edition annex_edition
                               appendix_edition volume_edition].freeze
+      # The S-4 anchor: the loose-leaf publication every spec citation
+      # resolves through (bare "B-401" carries it implicitly).
+      S4_TYPE = "S"
+      S4_NUMBER = "4"
+      # A citation letter is one of S-4's lettered Parts; the section
+      # vocabulary (100-600, Part C 100-500) is theirs.
+      SPEC_LETTERS = %w[A B C].freeze
+      # Components an S-4 spec citation cannot carry: the citation is a
+      # leaf of the Part, not a wrappable publication.
+      SPEC_FOREIGN_COMPONENTS = %i[supplement annex appendix
+                                   appendix_subnumber volume issue].freeze
 
       def build(parsed)
         hash = parsed.is_a?(Array) ? parsed.reduce({}, :merge) : parsed
         attrs = stringified_attrs(hash)
+        resolve_spec_citation!(attrs)
+        type = type_letter_from(hash, attrs)
+        assert_spec_anchor!(attrs, type)
         assert_edition_mode!(attrs)
-        klass = Pubid::Iho.identifier_klass_for_type_letter(stringify(hash[:type]))
+        klass = Pubid::Iho.identifier_klass_for_type_letter(type)
         klass.new(**attrs)
       end
 
@@ -39,6 +55,93 @@ module Pubid
 
       private
 
+      # The citation captures resolve onto the model (see the grammar
+      # header): the citation letter folds into `part` (a Part-rule
+      # capture must agree), and the long form's spelled section becomes
+      # the spec alone — beside a citation it only cross-checks the
+      # citation's derived section ("Part B, Section 400, B-401" stores
+      # spec 401; "Part B, Section 500, B-401" is rejected).
+      def resolve_spec_citation!(attrs)
+        letter = attrs.delete(:spec_part)
+        spelled = attrs.delete(:spec_section)
+        attrs[:part] = merge_citation_letter!(attrs[:part], letter) if letter
+        apply_spelled_section!(attrs, spelled)
+        assert_citation_shape!(attrs) if attrs[:spec]
+      end
+
+      def apply_spelled_section!(attrs, spelled)
+        return if spelled.nil?
+        return attrs[:spec] = spelled unless attrs[:spec]
+
+        return if spelled == spec_section_of(attrs[:spec])
+
+        raise ArgumentError,
+              "the spelled section #{spelled} disagrees with the " \
+              "citation #{attrs[:part]}-#{attrs[:spec]}"
+      end
+
+      def spec_section_of(spec)
+        "#{spec[0]}00"
+      end
+
+      def merge_citation_letter!(part, letter)
+        return letter if part.nil? || part == letter
+
+        raise ArgumentError,
+              "the citation letter #{letter} conflicts with part #{part}"
+      end
+
+      def assert_citation_shape!(attrs)
+        assert_citation_letter!(attrs)
+        assert_citation_leaf!(attrs)
+      end
+
+      def assert_citation_letter!(attrs)
+        return if SPEC_LETTERS.include?(attrs[:part])
+
+        raise ArgumentError,
+              "an S-4 spec citation needs a lettered Part (A/B/C), " \
+              "not #{attrs[:part].inspect}"
+      end
+
+      # The citation is a leaf of its Part: it carries no component
+      # edition and none of the wrappable components.
+      def assert_citation_leaf!(attrs)
+        if attrs[:part_edition] || attrs[:part_year]
+          raise ArgumentError,
+                "a spec citation rides the S-4 edition, not a part edition"
+        end
+
+        foreign = attrs.slice(*SPEC_FOREIGN_COMPONENTS).compact.keys
+        return if foreign.empty?
+
+        raise ArgumentError,
+              "an S-4 spec citation is a leaf of its Part and cannot " \
+              "carry #{foreign.join(', ')}"
+      end
+
+      # The series letter: a bare citation branch parse has no series
+      # capture, and its anchor is implicitly the S-4 publication (the
+      # number binds with it).
+      def type_letter_from(hash, attrs)
+        type = stringify(hash[:type])
+        return type if type
+
+        raise ArgumentError, "unknown IHO series" unless attrs[:spec]
+
+        attrs[:number] = S4_NUMBER
+        S4_TYPE
+      end
+
+      def assert_spec_anchor!(attrs, type)
+        return unless attrs[:spec]
+        return if type == S4_TYPE && attrs[:number] == S4_NUMBER
+
+        raise ArgumentError,
+              "an S-4 spec citation requires the S-4 anchor: " \
+              "#{type}-#{attrs[:number]} cannot carry spec #{attrs[:spec]}"
+      end
+
       # The two publication modes are mutually exclusive: an identifier
       # is either within-edition (a base edition its components ride) or
       # separately-published (a component carries its own edition and

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

@@ -8,6 +8,11 @@ module Pubid
     # IHO identifiers have the form:
     #   IHO {S|P|M|B|C}-{number}[ {edition}| Vol. N [(issue)]]
     #       [ Sup N][ Part X][ Annex A][ Appendix B[-2]] [(2024)]
+    # The S-4 loose-leaf publication adds the spec citation
+    #   IHO S-4 [edition] <letter>-<hundreds><seq>[.sub][(variant)]
+    # ("IHO S-4 B-401", the long form "S-4 Part B, Section 400" and the
+    # bare "B-401" all parse to it; `spec` stores the leaf number, the
+    # citation letter rides `part`, the section is a derived reader).
     #
     # Every tail component is a first-class semantic component: a typed
     # attribute, independently addressable, URN-encodable and matchable.
@@ -83,6 +88,15 @@ module Pubid
       attribute :issue,      :string
       attribute :volume_edition, :string
       attribute :volume_year,    :string
+      # The S-4 loose-leaf spec citation (issue #691): `spec` is the leaf
+      # number ("401" of B-401), the citation letter rides `part` (the
+      # builder folds it in), the dotted sub and the parenthesized
+      # variant keep their own components. The SECTION (the hundreds
+      # digit) is never stored — a derived reader — and the `00` slot
+      # (B-400) IS the section-level citation.
+      attribute :spec,         :string
+      attribute :spec_sub,     :string
+      attribute :spec_variant, :string
 
       # Polymorphic type map for lutaml::Model key_value serialization: maps
       # each subclass's polymorphic_name to its class name so `from_hash` can
@@ -122,6 +136,9 @@ module Pubid
         map "volume_edition",     to: :volume_edition
         map "volume_year",        to: :volume_year
         map "issue",              to: :issue
+        map "spec",               to: :spec
+        map "spec_sub",           to: :spec_sub
+        map "spec_variant",       to: :spec_variant
       end
 
       # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
@@ -139,9 +156,40 @@ module Pubid
         args = args.dup
         args << :issue if args.include?(:volume)
         args << :appendix_subnumber if args.include?(:appendix)
+        # The spec citation is the leaf: a reference that omits the spec
+        # nils its sub and variant with it.
+        args.push(:spec_sub, :spec_variant) if args.include?(:spec)
         super
       end
 
+      # The citation letter of an S-4 spec (nil unless the identifier IS
+      # a spec citation): the part carries the letter, the same way the
+      # long form spells it ("Part B" of "B-401").
+      def spec_part
+        spec && part
+      end
+
+      # The section an S-4 spec belongs to: the hundreds digit of the
+      # spec number, zero-padded (B-401 -> "400"; B-400 derives its own
+      # section). DERIVED, never stored, never emitted — the owner
+      # ruling keeps the spec number the leaf.
+      def spec_section
+        return nil unless spec
+
+        "#{spec[0]}00"
+      end
+
+      # True when the spec number is reserved ("NOT CURRENTLY USED") in
+      # the edition's S-4 contents (data/iho/s4-reserved-specs.yaml). An
+      # edition-less reference is reserved when any seeded edition
+      # reserves the number. A reserved citation parses and resolves AS
+      # RESERVED, never invalid (issue #691).
+      def reserved?
+        return false unless spec
+
+        ReservedSpecs.reserved?(edition, part, spec)
+      end
+
       # Render the compact face: the code-adjacent components folded onto
       # the code with separators — the supplement and the part hyphenated
       # (`IHO M-2-2` for `IHO M-2 Sup 2`, `IHO S-5-B` for `IHO S-5 Part B`,
@@ -153,7 +201,10 @@ module Pubid
       def render(format: :human, **opts)
         compact = opts.delete(:compact)
         result = super
-        compact && format == :human ? compact_face(result) : result
+        # A spec citation's canonical face IS the compact form (the
+        # citation is already folded onto the code: "IHO S-4 B-401"), so
+        # the compact flag is a no-op for it.
+        compact && format == :human && !spec ? compact_face(result) : result
       end
 
       # The shared mr_string path reads `edition&.number` (the base

data/lib/pubid/iho/pubid_urn_schema.rb

@@ -13,10 +13,11 @@ module Pubid
     # edition/year right after it — supplement, part, annex, appendix (the
     # two-level Appendix D-2 keeps the subnumber as its own atom), volume
     # (the unified locator, yearbook volumes included: `vol-2024`), issue.
-    # Letters stay case-preserved (`part-A`). The legacy `y.` yearbook
-    # marker is decodable in the official URN parser, never emitted here:
-    # a periodical has no `year-` atom value, its volume carries the year.
-    # The official urn:mrn:iho:… form stays on #to_urn.
+    # The S-4 spec citation sits inside its part (`spec-`, `specsub-`,
+    # `specvar-`). Letters stay case-preserved (`part-A`). The legacy
+    # `y.` yearbook marker is decodable in the official URN parser, never
+    # emitted here: a periodical has no `year-` atom value, its volume
+    # carries the year. The official urn:mrn:iho:… form stays on #to_urn.
     PubidUrnSchema = Pubid::PubidUrn.define("iho") do
       atom "edition", "ed"
       atom "year", "year"
@@ -26,6 +27,12 @@ module Pubid
       atom "part", "part"
       atom "part_edition", "parted"
       atom "part_year", "party"
+      # The S-4 loose-leaf spec citation (issue #691): a child of the
+      # part (the citation letter rides `part-`); the section is
+      # derivable from the spec's hundreds digit — never an atom.
+      atom "spec", "spec"
+      atom "spec_sub", "specsub"
+      atom "spec_variant", "specvar"
       atom "annex", "annex"
       atom "annex_edition", "anned"
       atom "annex_year", "annyear"

data/lib/pubid/iho/renderer.rb

@@ -19,6 +19,13 @@ module Pubid
     #                                   beside an edition is the date
     #                                   qualifier on standards,
     #                                   parenthesized — the only year face
+    #   "IHO S-4 B-401"                 the S-4 spec citation (the long
+    #                                   form "S-4 Part B, Section 400"
+    #                                   parses to the same identity and
+    #                                   renders compact: the citation
+    #                                   replaces the Part face; the
+    #                                   section is derivable, never
+    #                                   printed)
     #
     # The renderer is registered as the `:human` format in the IHO format
     # registry and invoked via `render(format: :human)`; the compact face
@@ -32,12 +39,17 @@ module Pubid
       # edition (+ parenthesized year) right after it; the appendix joins
       # its subnumber; the issue rides parenthesized after its volume;
       # the base year prints only as the parenthesized with-year
-      # qualifier.
+      # qualifier. The S-4 spec citation face (" B-401") sits where the
+      # Part face sits — it REPLACES the Part face when a spec is
+      # present (the citation letter is the part), printing
+      # "<letter>-<number>" with the dotted sub and the parenthesized
+      # variant folded on.
       FACES = [
         [:edition, " %s"],
         [:supplement, " Sup %s"], [:supplement_edition, " %s"],
         [:supplement_year, " (%s)"],
         [:part, " Part %s"], [:part_edition, " %s"], [:part_year, " (%s)"],
+        [:spec, " %s"],
         [:annex, " Annex %s"], [:annex_edition, " %s"], [:annex_year, " (%s)"],
         [:appendix, " Appendix %s"], [:appendix_subnumber, "-%s"],
         [:appendix_edition, " %s"], [:appendix_year, " (%s)"],
@@ -50,11 +62,36 @@ module Pubid
         id = @id
         rendered = "#{id.publisher} #{id.class.type[:short]}-#{id.number}"
         FACES.each do |component, face|
-          value = id.public_send(component)
+          value = face_value(id, component)
           rendered << (face % value) if value
         end
         rendered
       end
+
+      private
+
+      # nil = the face does not print. The citation face replaces the
+      # Part face (same containment slot: the citation letter IS the
+      # part), and it prints only on a spec citation.
+      def face_value(id, component)
+        if component == :spec
+          return nil unless id.spec
+
+          return spec_citation(id)
+        end
+        return nil if component == :part && id.spec
+
+        id.public_send(component)
+      end
+
+      # "B-401", "B-122.1", "B-521(I)", "B-351.1(I)" — the citation the
+      # S-4 contents and cross-references print.
+      def spec_citation(id)
+        citation = "#{id.part}-#{id.spec}"
+        citation << ".#{id.spec_sub}" if id.spec_sub
+        citation << "(#{id.spec_variant})" if id.spec_variant
+        citation
+      end
     end
   end
 end

data/lib/pubid/iho/reserved_specs.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Pubid
+  module Iho
+    # The S-4 reserved specification registry
+    # (data/iho/s4-reserved-specs.yaml): the "NOT CURRENTLY USED"
+    # numbers, edition-keyed (owner rulings of 2026-11-11, issue #691).
+    # {Reserved?} answers from this table — a reserved number parses and
+    # resolves AS RESERVED, never invalid.
+    module ReservedSpecs
+      DATA_PATH =
+        File.expand_path("../../../data/iho/s4-reserved-specs.yaml", __dir__)
+
+      class << self
+        # True when the part-lettered spec number is reserved in the
+        # given S-4 edition. An edition-less reference is reserved when
+        # ANY seeded edition reserves the number: the number is out of
+        # circulation in every edition that names it.
+        def reserved?(edition, part, spec)
+          return false unless part && spec
+
+          if edition
+            specs_for(edition, part).include?(spec)
+          else
+            registry.values.any? do |parts|
+              specs_for_parts(parts, part).include?(spec)
+            end
+          end
+        end
+
+        # The edition-keyed registry: edition => part letter => spec
+        # numbers.
+        def registry
+          @registry ||=
+            (YAML.safe_load_file(DATA_PATH) || {}).transform_values do |parts|
+              parts.transform_values { |specs| Array(specs) }
+            end
+        end
+
+        private
+
+        def specs_for(edition, part)
+          specs_for_parts(registry.fetch(edition, {}), part)
+        end
+
+        def specs_for_parts(parts, part)
+          parts.fetch(part, [])
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iho/urn_generator.rb

@@ -31,6 +31,7 @@ module Pubid
     # - urn:iho:m:2:sup-1                         IHO M-2 Sup 1
     # - urn:iho:p:5:vol-2024                      IHO P-5 Vol. 2024
     # - urn:iho:p:1:vol-30:issue-2                IHO P-1 Vol. 30 (2)
+    # - urn:iho:s:4:ed-4.10.0:part-B:spec-401     IHO S-4 4.10.0 B-401
     class UrnGenerator
       attr_reader :identifier
 
@@ -49,6 +50,11 @@ module Pubid
         [:supplement, "sup"], [:supplement_edition, "ed"],
         [:supplement_year, "year"],
         [:part, "part"], [:part_edition, "ed"], [:part_year, "year"],
+        # the S-4 spec citation: a child of its part (the citation
+        # letter rides the part- atom), the dotted sub and the
+        # parenthesized variant its own children. The SECTION is NOT
+        # emitted — derivable from the spec's hundreds digit.
+        [:spec, "spec"], [:spec_sub, "specsub"], [:spec_variant, "specvar"],
         [:annex, "annex"], [:annex_edition, "ed"], [:annex_year, "year"],
         [:appendix, "appendix"], [:appendix_subnumber, nil],
         [:appendix_edition, "ed"], [:appendix_year, "year"],

data/lib/pubid/iho/urn_parser.rb

@@ -7,8 +7,8 @@ module Pubid
     # the segment table lives in the grammar header and the flavor notes):
     #
     #   urn:iho:<type>:<number>[:ed-<x.y.z>][:sup-<n>][:part-<X>]
-    #     [:annex-<A>][:appendix-<B>][:<sub>][:vol-<n>][:issue-<n>]
-    #     [:year-<yyyy>]
+    #     [:spec-<n>[:specsub-<n>][:specvar-<X>]][:annex-<A>]
+    #     [:appendix-<B>][:<sub>][:vol-<n>][:issue-<n>][:year-<yyyy>]
     #
     # Segment discipline (mirrors the ISO URN parser's strictness):
     # - the docnumber occupies every leading bare number segment up to
@@ -22,7 +22,11 @@ module Pubid
     #   directly after its appendix segment (a year is always
     #   marker-tagged, so a bare digit there can only be the subnumber);
     # - the issue is allowed only beside its volume and validated as
-    #   digits.
+    #   digits;
+    # - the S-4 spec atom is a child of its part (the citation letter
+    #   rides the part- atom): specsub-/specvar- only after spec-, and
+    #   no ed-/year- after a spec node (the spec rides its publication's
+    #   edition; the section is derivable, never emitted).
     #
     # Legacy 2.0.x spellings remain decodable but are never emitted:
     # the bare a.b.c edition segment, the dotted keys part./annex./
@@ -38,6 +42,7 @@ module Pubid
     # - urn:iho:p:5:vol-2024                   → IHO P-5 Vol. 2024
     # - urn:iho:p:1:vol-30:issue-2             → IHO P-1 Vol. 30 (2)
     # - urn:iho:s:158:100                      → IHO S-158:100
+    # - urn:iho:s:4:ed-4.10.0:part-B:spec-401  → IHO S-4 4.10.0 B-401
     class UrnParser < Pubid::UrnParser::Base
       TYPE_LETTERS = %w[s p m b c].freeze
 
@@ -50,6 +55,9 @@ module Pubid
         "ed" => [:edition, /\A\d+\.\d+\.\d+\z/],
         "sup" => [:supplement, /\A\d+\z/],
         "part" => [:part, /\A(?:\d+[a-zA-Z]*|[A-Z]|[SPMBC]-\d+)\z/],
+        "spec" => [:spec, /\A[1-6]\d\d\z/],
+        "specsub" => [:spec_sub, /\A\d+\z/],
+        "specvar" => [:spec_variant, /\A[A-Z]+\z/],
         "annex" => [:annex, /\A[A-Z]\z/],
         "appendix" => [:appendix, /\A(?:[A-Z]|\d+)\z/],
         "vol" => [:volume, /\A\d+\z/],
@@ -63,6 +71,12 @@ module Pubid
       # follow (the component-edition duality).
       POSITIONAL_MARKERS = %i[edition year].freeze
 
+      # The S-4 spec node and its children: specsub-/specvar- are only
+      # allowed after their parent, and an S-4 spec rides its
+      # publication's edition — no ed-/year- inside a spec.
+      SPEC_NODES = %i[spec spec_sub spec_variant].freeze
+      SPEC_PARENTS = %i[spec spec_sub].freeze
+
       # Legacy dotted keys (deprecated; decodable, never emitted).
       # "ap" is the pre-positional appendix tag; "suppl" the pre-positional
       # supplement tag; "y" the pre-positional year tag — under the
@@ -97,11 +111,22 @@ module Pubid
         # own edition).
         ctx = { component: nil, edition_owner: nil }
         consume_segments!(attrs, segments, ctx, urn)
-        Builder.build({ type: type_token.upcase, **attrs })
+        build_identifier({ type: type_token.upcase, **attrs }, urn)
       end
 
       private
 
+      # The semantic validations the builder applies to the decoded shape
+      # (the S-4 anchor, the citation letter) are URN validation at this
+      # layer: a URN that asserts a citation it cannot carry is a
+      # malformed URN, and the raw ArgumentError stays as the cause.
+      def build_identifier(hash, urn)
+        Builder.build(hash)
+      rescue ArgumentError => e
+        raise Pubid::Errors::UrnParseError,
+              "#{e.message} in #{urn.inspect}"
+      end
+
       def read_type!(segments, urn)
         type_token = segments.shift.to_s.downcase
         return type_token if TYPE_LETTERS.include?(type_token)
@@ -159,10 +184,9 @@ module Pubid
         marker, value = MARKER_RE.match(segment).captures
         key, pattern = MARKERS.fetch(marker)
         raise_invalid!(marker, value, urn) unless value.match?(pattern)
-
-        if POSITIONAL_MARKERS.include?(key)
-          return consume_positional!(attrs, key, value, ctx, urn)
-        end
+        assert_spec_parent!(key, ctx, urn)
+        return consume_positional!(attrs, key, value, ctx, urn) if
+          POSITIONAL_MARKERS.include?(key)
 
         store!(attrs, key, value, urn)
         ctx[:component] = key
@@ -170,6 +194,16 @@ module Pubid
         consume_subnumber!(attrs, key, segments, ctx, urn)
       end
 
+      # specsub-/specvar- are children of the spec atom — allowed only
+      # in their parent's slot (the SEGMENTS table in the generator).
+      def assert_spec_parent!(key, ctx, urn)
+        return unless %i[spec_sub spec_variant].include?(key)
+        return if SPEC_PARENTS.include?(ctx[:component])
+
+        raise Pubid::Errors::UrnParseError,
+              "#{key}- is only allowed after spec- in #{urn.inspect}"
+      end
+
       def raise_invalid!(marker, value, urn)
         raise Pubid::Errors::UrnParseError,
               "Invalid #{marker} value #{value.inspect} in #{urn.inspect}"
@@ -177,8 +211,15 @@ module Pubid
 
       # ed- and year- are POSITIONAL markers (see the marker docs): the
       # edition attaches to the component it follows, the year to the
-      # edition owner.
+      # edition owner. An S-4 spec carries neither — it rides its
+      # publication's edition.
       def consume_positional!(attrs, key, value, ctx, urn)
+        if SPEC_NODES.include?(ctx[:component])
+          raise Pubid::Errors::UrnParseError,
+                "an S-4 spec rides its publication's edition: #{key}- " \
+                "cannot follow a spec segment in #{urn.inspect}"
+        end
+
         if key == :edition
           return store_component_scoped!(attrs, :edition, value, ctx, urn)
         end

data/lib/pubid/iho.rb

@@ -12,6 +12,7 @@ module Pubid
     autoload :Identifier, "#{__dir__}/iho/identifiers/base"
     autoload :Identifiers,  "#{__dir__}/iho/identifiers"
     autoload :Renderer,     "#{__dir__}/iho/renderer"
+    autoload :ReservedSpecs, "#{__dir__}/iho/reserved_specs"
     autoload :UrnGenerator, "#{__dir__}/iho/urn_generator"
     autoload :UrnParser, "#{__dir__}/iho/urn_parser"
     autoload :PubidUrnSchema, "#{__dir__}/iho/pubid_urn_schema"

data/lib/pubid/nist/CLAUDE.md

@@ -135,3 +135,14 @@ Read this before you change `lib/pubid/nist/` or `spec/pubid/nist/`. The root
   `spec/pubid/nist/bare_series_reference_spec.rb`; the corpus round froze
   the six rows (`NBS CS`, `NBS CSM`, `NBS CIS`, `NBS CS-E`, `NIST PS`,
   `NIST DCI`) into the testsuite with the gem twin in lockstep.
+
+- **"FIPS PUB <number>" is a preprocessor alias, not a grammar face
+  (pubid#697).** NIST prints the series as "FIPS PUB <number>" but the
+  grammar reads "NIST FIPS <number>", so `normalize_fips_pub_alias!`
+  (head-anchored, immediately after the publisher/series stage) rewrites
+  the printed prefix and the parse lands on exactly the canonical model —
+  hash-, render-, URN- and MR-identical to "NIST FIPS <number>". The
+  hyphenated numbers and the revision forms the grammar models
+  ("FIPS PUB 199 Rev. 1" with its `original_prefix` facet, compact
+  "rev1") ride the prefix alias; bare "FIPS <number>"
+  (publisher_was_parsed: false) and NBS FIPS are untouched.

data/lib/pubid/nist/preprocessor.rb

@@ -68,6 +68,7 @@ module Pubid
         end
         normalize_spurious_u_suffix!
         normalize_publisher_and_series!
+        normalize_fips_pub_alias!
         normalize_lcirc_supplement_contexts!
         normalize_revision_spacing!
         normalize_letter_suffix_casing!
@@ -124,6 +125,21 @@ module Pubid
         @cleaned = @cleaned.gsub(/\bLC\b(?!IRC)/, "LCIRC")
       end
 
+      # The FIPS series' own printed face: NIST prints the series as
+      # "FIPS PUB <number>" (document cover and catalogue style), so the
+      # grammar accepts the publisher-prefixed canonical form only through
+      # this alias (pubid#697). Rewrites the prefix to "NIST FIPS", the
+      # spelling the grammar already reads, and the printed-form parse
+      # therefore lands on exactly the model "NIST FIPS <number>" builds
+      # (same to_hash, same render, revision spellings like
+      # "FIPS PUB 199 Rev. 1" included). Anchored at the head and run
+      # before every other stage so later digit/marker stages see the
+      # canonical face; "FIPS" alone (publisher_was_parsed: false) is
+      # untouched.
+      def normalize_fips_pub_alias!
+        @cleaned = @cleaned.sub(/\AFIPS PUB\b/i, "NIST FIPS")
+      end
+
       # LCIRC series: combine with NBS prefix when a supplement marker
       # follows, and convert MR-format dots to spaces so the grammar's
       # circ_supplement_identifier rule can match.

data/lib/pubid/plateau/CLAUDE.md

@@ -11,3 +11,38 @@ 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.
+
+## Handbook volume label (本編 / 本編＋付録)
+
+MLIT publishes Handbook #00 edition 5.0 twice on one date: `第5.0版　本編`
+(main volume) and `第5.0版　本編＋付録` (main volume and appendix, one PDF);
+edition 6.0 only as `本編＋付録`. `Identifiers::Handbook#volume` keeps that
+label as Japanese text, as `edition` keeps `第X.Y版`. The grammar accepts it
+only after an edition, separated by an ASCII or a full-width (U+3000) space,
+with `＋` or ASCII `+`; the builder normalizes `+` to `＋`, and `to_s` writes
+one ASCII space before it. The renderer prints the volume only after an
+edition, so `exclude(:edition)` still renders a string that parses.
+`volume` is in `==` and is `subset_strict`, so `#00 第5.0版` matches neither
+labelled publication. A nil volume leaves no key in `to_hash`, so the
+existing index-v2 rows keep their hash. The pubid-scheme URN carries it as
+the `vol-` atom; `to_urn` is unchanged (it has no edition either). Locked by
+`spec/pubid/plateau/handbook_volume_spec.rb`.
+
+Known gaps, not caused by this change: a Technical Report drops an edition
+and a volume without a diagnostic (the `handbook` rule matches any
+`doc_type`), and `to_mr_string` raises for every Handbook with an edition
+(the base `mr_edition` calls `edition.number` on a String).
+
+## The grammar is baked here ahead of pubid-grammar
+
+`data/parg/plateau.json` was compiled here from its own embedded `source`
+plus the volume rule, at parsanol **1.3.114** (the version of the earlier
+bake; force it with `gem "parsanol", "1.3.114"`, as
+`pubid-grammar/scripts/bake-one.rb` does, because the binstub resolves the
+latest installed gem). Until pubid-grammar takes hand-off
+`pubid__pubid-grammar__plateau-handbook-volume`, its `grammars/plateau.parg`
+is the OLD grammar. To change the grammar, extract the source with
+`jq -j .source data/parg/plateau.json` (`-j`: the source has no trailing
+newline, and one extra byte changes the checksum), edit, re-bake, then run
+`bundle exec parsanol parg test data/parg/plateau.json`. Read the `.parg`
+file as UTF-8: under a US-ASCII locale the parsanol lexer raises on `第`.

data/lib/pubid/plateau/builder.rb

@@ -34,6 +34,10 @@ module Pubid
         if parsed[:edition] && klass == Identifiers::Handbook
           params[:edition] = parsed[:edition].to_s
         end
+        # The grammar accepts an ASCII "+"; MLIT prints the full-width "＋".
+        if parsed[:volume] && klass == Identifiers::Handbook
+          params[:volume] = parsed[:volume].to_s.tr("+", "＋")
+        end
 
         klass.new(**params)
       end

data/lib/pubid/plateau/identifiers/handbook.rb

@@ -4,10 +4,18 @@ module Pubid
   module Plateau
     module Identifiers
       # PLATEAU Handbook
-      # Format: PLATEAU Handbook #NN[-annex] [第X.Y版]
+      # Format: PLATEAU Handbook #NN[-annex] [第X.Y版[ volume]]
       # Example: PLATEAU Handbook #00 第1.0版
+      # Example: PLATEAU Handbook #00 第5.0版 本編＋付録
       class Handbook < Identifier
         attribute :edition, :string, default: -> {}
+        # The volume label MLIT prints after the edition: "本編" (the main
+        # volume alone) or "本編＋付録" (main volume and appendix, one PDF).
+        attribute :volume, :string, default: -> {}
+
+        # A nil `volume` means the publication has no volume label:
+        # `#00 第5.0版` does not subsume `#00 第5.0版 本編＋付録`.
+        subset_strict :volume
 
         def type_string
           "Handbook"
@@ -20,7 +28,7 @@ module Pubid
         def ==(other)
           return false unless other.is_a?(Handbook)
 
-          super && edition == other.edition
+          super && edition == other.edition && volume == other.volume
         end
       end
     end

data/lib/pubid/plateau/pubid_urn_schema.rb

@@ -13,6 +13,7 @@ module Pubid
       atom "publisher", "pub"
       atom "edition", "ed"
       atom "annex", "annex", kind: :int
+      atom "volume", "vol"
 
       number = [["number", :int]]
       type "pubid:plateau:annex", "annex", core: [],