pubid 2.0.21 → 2.0.23

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

@@ -136,13 +136,87 @@ Read this before you change `lib/pubid/nist/` or `spec/pubid/nist/`. The root
   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.
+- **"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`.
+
+- **The default-series plain-number branch (pubid#711).** A citation
+  shaped like the docnumber — "800-90B", the docid-derived citation face
+  of NIST.SP.800-90B — and its publisher-led spelling "NIST 800-90B"
+  carry NO series token, and the grammar's series alternatives never
+  reached them: every branch demanded a series token (or, after a bare
+  publisher, only the dated ISO-date digits). The grammar (nist.parg,
+  fleet compiler 1.3.126) gained two trailing `identifier` alternatives
+  that ride the SAME report-number tail as the series-bearing branches —
+  `(publisher) (space) (report_number) …` and bare `(report_number) …` —
+  placed LAST so PEG ordering leaves every previously accepted form on
+  its original alternative (they only catch inputs that previously
+  failed outright). The identity defaults onto the SP series: the Router
+  dispatches `SpecialPublication` when the parse carries no series and
+  no dated date, and the Builder fills `series` from the new
+  `Identifier.default_series` class method (SP is the default — the
+  docid of the real document is NIST.SP.800-90B). The publisher rides
+  the #704 machinery: `SpecialPublication.series_default_publisher` is
+  now "NIST", so the bare parse fills the publisher after
+  `publisher_was_parsed: false` and is `==` to the spelled form (URN-,
+  MR- and hash-equal but for that equality-ignored flag; the MR face is
+  the exact "NIST.SP.800-90B" DOI surface relaton-data-nist stores).
+  The SHORT face keeps the bare spelling (publisher suppressed);
+  the MR face always carries the publisher (`to_mr_style` prints
+  `(publisher || "NIST")`), so the bare parse lands on the DOI-style
+  face directly. The dated alternative keeps priority
+  ("NIST 2023-04-15 001" stays `DatedDocument`), and the routing probe
+  ("zzqx-nonsense-9714") still fails, so NIST is not disqualified as a
+  `Pubid.parse` fallback. `to_hash` of the two bare-series probes
+  ("SP 123", "SP 800-90B") gained `publisher: NIST` — the #704 ruling
+  generalized to the SP series; no corpus row moved. Locked by
+  `spec/pubid/nist/default_series_plain_number_spec.rb`; the corpus
+  round froze the four faces (the two publisher-led spellings as
+  non-normalized aliases of the canonical cases, the two bare ones as
+  canonical `publisher_was_parsed: false` cases) with the gem twin in
+  lockstep.

data/lib/pubid/nist/builder.rb

@@ -99,6 +99,16 @@ module Pubid
         # Locate the appropriate identifier class via Router
         identifier = @router.locate_identifier_klass(parsed_hash).new
 
+        # The default-series plain-number branch (pubid#711): the grammar's
+        # trailing alternatives carry no series token ("800-90B" /
+        # "NIST 800-90B"), so the identity gains the class's default series
+        # and parses == to the spelled "NIST SP 800-90B" form. The bare
+        # publisher rides the #704 rule below (apply_series_default_publisher).
+        if parsed_hash[:series].nil? &&
+            (default = identifier.class.default_series)
+          identifier.series = Components::Code.new(value: default)
+        end
+
         # Resolve the series policy once — every series-specific decision
         # flows through this object instead of branching on the parsed shape.
         series = Series.for(parsed_hash)
@@ -422,6 +432,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,39 @@ 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
+
+      # The series an input implies when it spells none — the grammar's
+      # default-series plain-number branch (pubid#711: "800-90B" /
+      # "NIST 800-90B" carry no series token). The Router dispatches the
+      # class from this default and the Builder fills the attribute, so a
+      # docnumber-shaped citation parses onto the same identity as the
+      # spelled form. nil: no default.
+      def self.default_series
+        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 +338,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 +358,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/identifiers/special_publication.rb

@@ -35,6 +35,21 @@ module Pubid
             { key: :sp,
             web: :special_publication, title: "NIST Special Publication", short: "SP" }
           end
+
+          # The default-series plain-number branch (pubid#711): a citation
+          # shaped like the docnumber ("800-90B", publisher-led
+          # "NIST 800-90B") names an SP document — the docid-derived
+          # citation of NIST.SP.800-90B is exactly "800-90B".
+          def default_series
+            "SP"
+          end
+
+          # A bare plain-number parse carries the series' NIST publisher
+          # (the #704 shape), so it is == to the spelled
+          # "NIST SP 800-90B" form a lookup compares against.
+          def series_default_publisher
+            "NIST"
+          end
         end
 
         def series_code

data/lib/pubid/nist/preprocessor.rb

@@ -125,19 +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.
+      # 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(/\AFIPS PUB\b/i, "NIST FIPS")
+        @cleaned = @cleaned.sub(/\A(?:NIST )?FIPS PUB\b/i, "NIST FIPS")
       end
 
       # LCIRC series: combine with NBS prefix when a supplement marker

data/lib/pubid/nist/router.rb

@@ -46,6 +46,17 @@ module Pubid
 
         series = parsed_hash[:series]&.to_s
 
+        # The default-series plain-number branch (pubid#711): the grammar's
+        # trailing alternatives accept a bare report number ("800-90B") and
+        # its publisher-led spelling ("NIST 800-90B") with NO series token.
+        # The SP series is the default: the docid-derived citation of
+        # NIST.SP.800-90B is exactly the bare docnumber "800-90B", and the
+        # Builder fills the same SP series the spelled form carries, so the
+        # two spellings are one identity to a lookup. No other branch can
+        # arrive here series-less (dated shapes returned above; every
+        # series-bearing branch captures :series).
+        return Identifiers::SpecialPublication if series.nil?
+
         # Handle compound series that include publisher (both space and dot separated)
         if series&.start_with?("NBS ")
           simple_series = series.sub("NBS ", "")

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/version.rb

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

data/lib/pubid.rb

@@ -224,6 +224,10 @@ module Pubid
   autoload :Ashrae, "pubid/ashrae"
   autoload :Asme, "pubid/asme"
   autoload :Doi, "pubid/doi"
+  # The PFS-compiled dev alias of doi (pubid/pubid#706): registered
+  # beside the coded flavor, never routed by Pubid.parse (registry keys
+  # sort "doi" first).
+  autoload :DoiPfs, "pubid/doi_pfs"
   autoload :Easc, "pubid/easc"
   autoload :Astm, "pubid/astm"
   autoload :Bipm, "pubid/bipm"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.21
+  version: 2.0.23
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-11 00:00:00.000000000 Z
+date: 2026-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -68,10 +68,12 @@ files:
 - conformance/pending.yaml
 - data/bipm/update_codes.yaml
 - data/ccsds/update_codes.yaml
+- data/iec/legacy-notation.md
 - data/iec/stage-codes.md
 - data/iec/update_codes.yaml
 - data/ieee/update_codes.yaml
 - data/iho/s4-reserved-specs.yaml
+- data/iso/historic-schemes.md
 - data/iso/update_codes.yaml
 - data/nist/series.yaml
 - data/nist/stages.yaml
@@ -95,6 +97,7 @@ files:
 - data/parg/cie.json
 - data/parg/csa.json
 - data/parg/doi.json
+- data/parg/doi_pfs.json
 - data/parg/easc.json
 - data/parg/ecma.json
 - data/parg/etsi.json
@@ -142,6 +145,7 @@ files:
 - data/parg/tables/organizations.yaml
 - data/parg/tables/tc_types.yaml
 - data/parg/tables/typed_stages.yaml
+- data/parg/tables/typed_stages_ballots.yaml
 - data/parg/tables/typed_stages_supplements.yaml
 - data/parg/tables/wg_types.yaml
 - data/parg/tgpp.json
@@ -467,6 +471,16 @@ files:
 - lib/pubid/doi/parser.rb
 - lib/pubid/doi/pubid_urn_schema.rb
 - lib/pubid/doi/renderer.rb
+- lib/pubid/doi_pfs.rb
+- lib/pubid/doi_pfs/CLAUDE.md
+- lib/pubid/doi_pfs/builder.rb
+- lib/pubid/doi_pfs/identifier.rb
+- lib/pubid/doi_pfs/identifiers.rb
+- lib/pubid/doi_pfs/identifiers/resource.rb
+- lib/pubid/doi_pfs/parser.rb
+- lib/pubid/doi_pfs/pubid_urn_schema.rb
+- lib/pubid/doi_pfs/renderer.rb
+- lib/pubid/doi_pfs/urn_generator.rb
 - lib/pubid/easc.rb
 - lib/pubid/easc/builder.rb
 - lib/pubid/easc/identifier.rb