pubid 2.0.20 → 2.0.22

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/iso/CLAUDE.md

@@ -158,3 +158,52 @@
   another reason — `DirectivesSupplement#supplement_publisher` is an
   `Iso::Components::Publisher` after `parse` and a `Pubid::Components::Publisher`
   after `from_hash` (11 supplements, 3 bundles).
+
+- **Historic TYPE-first ballot faces decode to the canonical on-base slash
+  form (owner ruling 2026-11-12, Option B — IHO-style decode-to-modern;
+  SSOT `data/iso/historic-schemes.md`).** The DAM-family token in TYPE
+  position (`ISO/IEC FDAM 1 14496-12:2004`, `ISO/PDAM 19973-2`) and the
+  space-attached ballot face (`ISO 15877-5:2009 FDAM 1`) used to raise; the
+  grammar (v0.5.0) gained two additive branches at the END of the
+  identifier alternation, so every face an existing member parses keeps its
+  exact parse (replayed: 15,307 fixture inputs and 213,414 stored
+  docidentifier faces byte-identical on `to_s`/`to_urn`/`to_hash`/
+  `to_mr_string`). What to know before editing either side:
+  - **The ballot token captures as `ballot_type_with_stage`** (table
+    `typed_stages_ballots`: PDAM, DAM, DAmd, FDAM, FDAmd, FPDAM), NOT as
+    `supp_type_with_stage` — a shared name would make the builder's
+    supplement-prefix peel wrap a second layer, while the stored twins keep
+    ONE level. `Builder#build_ballot_supplement` assembles the single
+    amendment layer and nests the rest (prefix, copublishers, the base's
+    own `type_with_stage` — the `TR` of `PDAM TR 9573-11` — and
+    `number_with_part`/`date`) as `:base`.
+  - **`ballot_number` is space-bounded on both sides** (mandatory trailing
+    space in the grammar group) so `PDAM 19973-2` cannot read 19973 as the
+    ballot number: with no second space the group backtracks and 19973
+    stays in `second_part`. This is the base-whole guard — the IEC-flavor
+    hazard (#693's `ensure_base`) of a base part migrating into the
+    supplement slot cannot happen here; the legacy slash-part of
+    `FPDAM 9075/1` stays a base part (`9075-1`).
+  - **The number precedence is TYPE token → on-base stamp → implied "1"**;
+    the stamp's number/date capture as `ballot_stamp_*` while its token
+    letters match UNCAPTURED (Option B keeps no spelling — the ballot's
+    stage is the TYPE token's). The implied 1 is the owner's no-number
+    rule, applied by `Builder#apply_implied_amendment_number` on EVERY
+    builder path (parse, URN, bundle members) for `Identifiers::Amendment`
+    with a nil number and `typed_stage.code` ∈ `{pdam, damd, fdamd, fpdam}`
+    — by `#code`, NOT `#stage_code` (PDAM's stage_code is `:cd`), and
+    `to_sym`-ed (the bound map delivers strings). The published stage
+    (abbr `Amd`) is out of scope: a numberless `ISO 1234/Amd` stays nil.
+  - **The `Am` spelling** joined `typed_stages_supplements` (after the Amd
+    entries) and the published stage's abbr list, so `/Am1:2006` parses as
+    an alias of `/Amd 1` through the EXISTING supplement branch and the
+    ballot stamp accepts it the same way. `detect_stage_format_long` now
+    treats an original spelling that is a prefix of the long abbr as the
+    long family, so `Am` renders canonical `Amd`; `AMD` still renders short
+    (facets keep spelling on render), `Amd.` still renders `Amd`.
+  - **The decode is one-way**: parse-in only, canonical renders emit the
+    on-base slash face, and a ballot face == its canonical spelling
+    (original_abbr is equality-ignored). Locked by
+    `spec/pubid/iso/ballot_face_decode_spec.rb` (all 13 SSOT anchors, the
+    no-number rule, base-whole guards, Am alias, stored-twin agreement, and
+    the website-face-vs-stored-face drift rows the SSOT §5 records).

data/lib/pubid/iso/builder.rb

@@ -151,6 +151,16 @@ module Pubid
         # reason). The document itself holds no all-parts mark.
         all_parts = parsed_hash.delete(:all_parts)
 
+        # Historic TYPE-first ballot face ("ISO/IEC FDAM 1 14496-12:2004",
+        # "ISO/PDAM 19973-2", "ISO 15877-5:2009 FDAM 1"): the ballot_* keys
+        # are one amendment layer over the whole base, never a second
+        # supplement layer (the stored twins keep one level), so the layer
+        # is assembled here, before the supplement-prefix peel could read
+        # the ballot token as an outer wrapper.
+        if parsed_hash.key?(:ballot_type_with_stage)
+          return build_ballot_supplement(parsed_hash, all_parts)
+        end
+
         # The copublisher tail captures as one scalar span ("/IEC/IEEE");
         # split it into the {copublisher:} element hashes the merge and
         # the :copublishers cast consume. A pre-built array (the URN
@@ -261,6 +271,10 @@ module Pubid
           identifier.type = default_typed_stage.to_type
         end
 
+        # The owner's no-number rule: a numberless DAM-family ballot-stage
+        # amendment is Amendment 1 (see the method comment).
+        apply_implied_amendment_number(identifier)
+
         all_parts ? identifier.to_all_parts : identifier
       end
 
@@ -306,6 +320,69 @@ module Pubid
         build(inner)
       end
 
+      # Historic TYPE-first ballot face (owner ruling 2026-11-12, Option B
+      # decode-to-modern): "[P|F]?DAM [N] BASE [stamp]" decodes to ONE
+      # amendment over the WHOLE base, rendered as the canonical on-base
+      # slash face. The stage comes from the ballot token; the number from
+      # the TYPE token, then the on-base stamp, then the owner's no-number
+      # rule (a ballot face with no number anywhere names Amendment 1 —
+      # identity-bearing, so it is set here at build time and serialized,
+      # not at render time); the stamp's date is the ballot supplement's
+      # date. The base keeps every component it carried: a legacy
+      # slash-part stays a part of the base number ("ISO/IEC FPDAM 9075/1"
+      # → base "9075-1"), and the base's own type token stays the base's
+      # ("ISO/IEC PDAM TR 9573-11" → base "TR 9573-11") — nothing migrates
+      # into the supplement slot. The stamp's token letters (Amd/Am/…) are
+      # decode-away: the ballot's stage is the TYPE token's.
+      #
+      # The rest of the hash — prefix, copublishers, the base's
+      # type_with_stage / number_with_part / date — is exactly the builder
+      # input of the base document, so it nests as :base and re-enters
+      # build.
+      def build_ballot_supplement(hash, all_parts)
+        fields = { type_with_stage: hash.fetch(:ballot_type_with_stage) }
+
+        number = hash[:ballot_number] ||
+                 hash[:ballot_stamp_number] ||
+                 hash[:ballot_stamp_dot_number] ||
+                 "1"
+        fields[:number_with_part] = number
+
+        if (stamp_date = hash[:ballot_stamp_date])
+          fields[:date] = stamp_date
+        end
+        if hash[:ballot_stamp_undated_marker]
+          fields[:undated_marker] = hash[:ballot_stamp_undated_marker]
+        end
+
+        rest = hash.except(:ballot_type_with_stage, :ballot_number,
+                           :ballot_stamp_number, :ballot_stamp_dot_number,
+                           :ballot_stamp_date, :ballot_stamp_undated_marker)
+
+        inner = { **fields, base: rest }
+        inner[:all_parts] = all_parts if all_parts
+        build(inner)
+      end
+
+      # The owner's no-number rule, applied on every construction path that
+      # routes through this builder (parse, URN, joint/bundle members): a
+      # DAM-family ballot-stage amendment token with no number anywhere
+      # names Amendment 1 ("ISO 19973-2/PDAM", "ISO/IEC PDAM 12207"). The
+      # number is identity-bearing, so the default lands at build time and
+      # to_hash serializes it — parse and from_hash(to_hash) agree because
+      # both carry the filled number. The ballot stages are matched by
+      # TypedStage#code (the per-typed-stage key) — PDAM's #stage_code is
+      # :cd, the harmonized range it lives in.
+      BALLOT_STAGE_CODES = %i[pdam damd fdamd fpdam].freeze
+
+      def apply_implied_amendment_number(identifier)
+        return unless identifier.is_a?(Identifiers::Amendment)
+        return unless identifier.number.nil?
+        return unless BALLOT_STAGE_CODES.include?(identifier.typed_stage&.code&.to_sym)
+
+        identifier.number = "1"
+      end
+
       def build_directive_supplement(hash, all_parts)
         fields = rekey_prefix(hash.slice(*DSUPP_KEYS), "dsupp_")
         rest = hash.except(*DSUPP_KEYS)

data/lib/pubid/iso/identifiers/amendment.rb

@@ -112,7 +112,7 @@ module Pubid
           ),
           ::Pubid::Components::TypedStage.new(
             code: :published,
-            abbr: ["Amd", "AMD", "Amd."],
+            abbr: ["Amd", "AMD", "Amd.", "Am"],
             short_abbr: "AMD",
             long_abbr: "Amd",
             type_code: :amd,

data/lib/pubid/iso/single_identifier.rb

@@ -36,7 +36,13 @@ module Pubid
         return false unless typed_stage
 
         ts = typed_stage
-        if ts.long_abbr && ts.original_abbr&.start_with?(ts.long_abbr)
+        original = ts.original_abbr
+        if ts.long_abbr && original && (original.start_with?(ts.long_abbr) ||
+                                        ts.long_abbr.start_with?(original))
+          # The long family: the canonical long spelling, its punctuated
+          # forms ("Amd." of "Amd"), and shorter long-family spellings
+          # ("Am" — the alias of "Amd" the owner ruled renders canonical).
+          # The short family ("AMD") matches neither direction.
           true
         elsif ts.long_abbr && ts.original_abbr&.include?("Directives")
           true

data/lib/pubid/nist/CLAUDE.md

@@ -135,3 +135,52 @@ 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 the official RENDER face; the preprocessor
+  alias exists so the spellings parse (pubid#697; owner ruling
+  2026-11-12).** FIPS is government-published and "PUB" (Federal
+  Information Processing Standards PUBlication) is part of the official
+  designation, so
+  `FederalInformationProcessingStandards#fips_render_lead` renders the
+  spelled-NIST-publisher rows as "FIPS PUB <number>" with the tails
+  riding the lead; the lead reads `printed_publisher`, so the
+  series-default NIST a bare parse fills (#704) is not a printed
+  publisher and the bare face stays bare. The grammar reads "NIST FIPS
+  <number>", so `normalize_fips_pub_alias!` (head-anchored, immediately
+  after the publisher/series stage) folds every printed spelling —
+  "FIPS PUB 205" and the publisher-prefixed "NIST FIPS PUB 205"
+  (pubid#702) — onto that canonical model, and all the spellings
+  converge on one identity: hash-, URN- and MR-identical, and one
+  render. 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), the historical NBS-prefixed rows, and
+  the MR face ("NIST.FIPS.197", an identity surface) are untouched.
+
+- **A bare "FIPS <number>" carries the series' NIST publisher (hand-off
+  nist-bare-fips-publisher, metanorma-pdfa#114).** relaton keeps a CSRC hit
+  only when the parsed citation is `==` to the row, and every row is
+  "NIST FIPS …", so a bare "FIPS 197" (publisher nil) answered "Not found".
+  The Builder now fills `identifier.class.series_default_publisher`
+  ("NIST" on `FederalInformationProcessingStandards`, nil on the base)
+  **after** it records `publisher_was_parsed: false`. The flag is
+  `equality_ignored`, so the two spellings are `==`; the short and MR faces
+  print the publisher only when it was spelled (`printed_publisher`), so the
+  bare face still renders `FIPS 197` / `FIPS.197`. The long and abbreviated
+  styles now name NIST (before, they began with a stray space). "NBS FIPS"
+  keeps its parsed NBS and is not `==` to the bare form. **NBS-era ruling**:
+  `#matches?` treats a publisher the query did not spell as a wildcard (and
+  no longer compares `publisher_was_parsed`, a spelling), so the query
+  "FIPS 46" still finds "NBS FIPS 46" — before this, a bare query matched
+  neither the NIST nor the NBS row. `===` needs the same rule
+  (`subset_skipped_attributes`), because the filled publisher is no longer
+  the nil the subset match read as "anything"; **the two primitives must
+  agree, so change them together.** `to_hash` of a bare parse gains
+  `publisher: NIST`; the 21,365-id `full/` corpus has no bare FIPS row, so
+  no fixture output moved. `from_hash` fills the default by the same rule
+  (`apply_series_default_publisher`, shared with the Builder), so a row
+  stored before this change (`publisher_was_parsed: false`, no publisher)
+  is still `==` to the parse. Not covered: `new(series:, number:)` fills
+  nothing (its flag defaults to true, so it means a spelled form anyway).
+  Locked by
+  `spec/pubid/nist/bare_fips_publisher_spec.rb`.

data/lib/pubid/nist/builder.rb

@@ -422,6 +422,11 @@ module Pubid
         # to_hash) when one was. Keeps the common publisher-bearing id lean.
         identifier.publisher_was_parsed = false unless identifier.publisher
 
+        # A series that implies its publisher (bare "FIPS 197" is
+        # "NIST FIPS 197") gets it now, after the flag above, so the two
+        # spellings are == while the bare face keeps rendering bare.
+        identifier.apply_series_default_publisher
+
         # NEW: Convert revision with month+year to update component (V1 compatibility)
         # Patterns like "NIST IR 4743rJun1992" should be rendered as "NIST IR 4743/Upd1-199206"
         if parsed_hash[:revision_month] && parsed_hash[:revision_year]

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

@@ -39,6 +39,10 @@ module Pubid
         id = super(normalize_deserialized_shapes(expand_compact_hash(data)),
                    options)
         derive_subseries(id)
+        # A bare-FIPS row written before the series default existed holds
+        # `publisher_was_parsed: false` and no publisher; parse now fills
+        # it, so from_hash must too, or the row is no longer == the parse.
+        id.apply_series_default_publisher if id.is_a?(Identifier)
         id
       end
 
@@ -291,6 +295,29 @@ module Pubid
         super + %i[update update_component]
       end
 
+      # The publisher a series implies when the input spells none. The
+      # Builder fills it after it records `publisher_was_parsed: false`, so
+      # the bare face still renders without the prefix. nil: no default.
+      def self.series_default_publisher
+        nil
+      end
+
+      # Fill the series default publisher on an id whose input spelled
+      # none. Shared by the Builder and from_hash, so both construction
+      # paths agree.
+      def apply_series_default_publisher
+        return if publisher || publisher_was_parsed
+
+        self.publisher = self.class.series_default_publisher
+      end
+
+      # `===` (subset match) follows #matches?: a publisher the reference
+      # did not spell is a wildcard, so bare "FIPS 46" finds "NBS FIPS 46".
+      def subset_skipped_attributes
+        skipped = super
+        publisher_was_parsed ? skipped : skipped | [:publisher]
+      end
+
       # Wildcard / partial-identifier match. Treats +self+ as a QUERY pattern
       # and +candidate+ as a concrete document: every ID part SET on the query
       # must equal the candidate's, while parts left unset (nil/empty) are
@@ -301,11 +328,16 @@ module Pubid
       # Asymmetric (unlike ==): "NBS CIRC 25".matches?("NBS CIRC 25sup1924")
       # is true, but not the reverse. The candidate must be the same class or
       # a subclass so series-level identity still holds.
+      #
+      # `publisher_was_parsed` records only how the query was spelled, so it
+      # is never a criterion; and a publisher the query did not spell (the
+      # series default a bare "FIPS 46" fills in) is a wildcard, so the bare
+      # query still finds the NBS-era "NBS FIPS 46".
       def matches?(candidate)
         return false unless candidate.is_a?(self.class)
 
         self.class.attributes.each_key.all? do |name|
-          next true if EQUALITY_IGNORED_ATTRS.include?(name)
+          next true unless match_criterion?(name)
 
           query_val = public_send(name)
           next true if query_val.nil?
@@ -316,6 +348,15 @@ module Pubid
         end
       end
 
+      # Whether #matches? compares attribute +name+ at all.
+      def match_criterion?(name)
+        return false if EQUALITY_IGNORED_ATTRS.include?(name)
+        return false if name == :publisher_was_parsed
+
+        name != :publisher || publisher_was_parsed
+      end
+      private :match_criterion?
+
       # NIST inherits Pubid::Identifier#exclude directly: it now rebuilds via
       # `self.class.new(**attrs)`, so NIST's keyword-only initialize
       # (initialize(**attributes)) works without a local override, and the base

data/lib/pubid/nist/identifiers/federal_information_processing_standards.rb

@@ -6,7 +6,9 @@ module Pubid
       # NIST Federal Information Processing Standards (FIPS)
       # Examples:
       # - "FIPS 140-3" (no NIST prefix)
-      # - "NIST FIPS 140-3" (also accepted, normalizes to FIPS 140-3)
+      # - "NIST FIPS 140-3" / "FIPS PUB 140-3" (also accepted; both parse
+      #   to the same identity, and the NIST-published face renders as
+      #   "FIPS PUB 140-3")
       class FederalInformationProcessingStandards < Identifier
         TYPED_STAGES = [
           Pubid::Components::TypedStage.new(
@@ -21,6 +23,13 @@ module Pubid
             TYPED_STAGES
           end
 
+          # Bare "FIPS 197" names the NIST document (NIST/CSRC list every
+          # FIPS, NBS-era ones included, as "NIST FIPS"). A parsed "NBS"
+          # stays NBS.
+          def series_default_publisher
+            "NIST"
+          end
+
           def type
             { key: :fips,
             web: :federal_information_processing_standards, title: "Federal Information Processing Standards",
@@ -41,8 +50,10 @@ module Pubid
         def to_mr_style
           # "NIST.FIPS.197" keeps a parsed publisher (the DOI suffix NIST
           # publishes); "FIPS.46e1977" has none and invents none.
+          # A bare "FIPS 197" carries the series default publisher NIST but
+          # did not spell it, so it prints no prefix either.
           # Note: edition is appended directly to number without dot for FIPS
-          result = [publisher, series_code].compact.join(".")
+          result = [printed_publisher, series_code].compact.join(".")
           result += ".#{number}" if number
 
           # FIPS uses dash notation for parts; render here and skip the generic
@@ -58,10 +69,30 @@ module Pubid
 
         public
 
+        # The short-face lead: the official printed "FIPS PUB" for a spelled
+        # NIST publisher (owner ruling 2026-11-12), the spelled historical
+        # publisher for NBS rows, and the bare series code when the input
+        # spelled no publisher — the series-default NIST a bare parse fills
+        # (#704) is not a printed publisher, so the bare face stays bare.
+        def fips_render_lead
+          lead_publisher = printed_publisher
+          return "FIPS PUB" if lead_publisher == "NIST"
+
+          spelled = lead_publisher && !lead_publisher.empty?
+          return "#{lead_publisher} #{series_code}" if spelled
+
+          series_code.to_s
+        end
+
         def to_short_style
-          # FIPS format: "FIPS 14e1971" or "NIST FIPS 140-3" (preserve publisher if set)
-          result = publisher ? "#{publisher} " : ""
-          result += series_code
+          # The official published face is "FIPS PUB <number>": FIPS is
+          # government-published, and "PUB" (Federal Information Processing
+          # Standards PUBlication) is part of the official designation
+          # (owner ruling 2026-11-12). The tail (volume/part/edition/
+          # supplement/update/draft) rides the lead unchanged, and the MR
+          # face ("NIST.FIPS.197") is an identity surface that does not
+          # move.
+          result = fips_render_lead
 
           if number
             # Convert dash-year patterns to edition format for FIPS
@@ -90,6 +121,14 @@ module Pubid
 
           result
         end
+
+        private
+
+        # The publisher the short and MR faces print: only one the input
+        # spelled, never the series default.
+        def printed_publisher
+          publisher if publisher_was_parsed
+        end
       end
     end
   end

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,23 @@ module Pubid
         @cleaned = @cleaned.gsub(/\bLC\b(?!IRC)/, "LCIRC")
       end
 
+      # The FIPS series' official printed face: FIPS is government-published
+      # and "PUB" (Federal Information Processing Standards PUBlication) is
+      # part of the official designation, so the RENDERER emits
+      # "FIPS PUB <number>" directly (owner ruling 2026-11-12). The grammar
+      # itself reads the publisher-bearing spelling only through this alias
+      # (pubid#697): it folds the printed spellings — "FIPS PUB 205" and the
+      # publisher-prefixed "NIST FIPS PUB 205" (pubid#702/#703) — onto the
+      # one model "NIST FIPS <number>" the grammar already builds (same
+      # to_hash, same URN, same MR string; revision spellings like
+      # "FIPS PUB 199 Rev. 1" included), while the renderer owns the printed
+      # face the fold converges to. Anchored at the head and run before
+      # every other stage so later digit/marker stages see the canonical
+      # spelling; "FIPS" alone (publisher_was_parsed: false) is untouched.
+      def normalize_fips_pub_alias!
+        @cleaned = @cleaned.sub(/\A(?:NIST )?FIPS 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/nist/urn_parser.rb

@@ -14,7 +14,7 @@ module Pubid
     # Examples:
     # - urn:nist:sp:800-53.supp        → NIST SP 800-53
     # - urn:nist:sp:800-53.r5.supp     → NIST SP 800-53r5
-    # - urn:nist:fips:199.supp         → NIST FIPS 199
+    # - urn:nist:fips:199.supp         → FIPS PUB 199
     class UrnParser < Pubid::UrnParser::Base
       TYPE_UPCASE = {
         "sp" => "SP",

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