pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

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

@@ -26,7 +26,8 @@ module Pubid
           end
 
           def type
-            { key: :rpt, title: "NBS Report", short: "RPT" }
+            { key: :rpt,
+            web: :report, title: "NBS Report", short: "RPT" }
           end
         end
 
@@ -52,13 +53,14 @@ module Pubid
         def to_short_style
           result = "#{default_publisher} #{series_code}"
           result += " #{number}" if number
-          result += supplement_short
+          result += append_short_components
           result
         end
 
         def to_mr_style
           result = "#{default_publisher}.#{series_code}"
           result += ".#{number}" if number
+          result += append_mr_components
           result
         end
       end

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

@@ -23,7 +23,8 @@ module Pubid
           end
 
           def type
-            { key: :sp, title: "NIST Special Publication", short: "SP" }
+            { key: :sp,
+            web: :special_publication, title: "NIST Special Publication", short: "SP" }
           end
         end
 

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

@@ -22,7 +22,8 @@ module Pubid
           end
 
           def type
-            { key: :tn, title: "NIST Technical Note", short: "TN" }
+            { key: :tn,
+            web: :technical_note, title: "NIST Technical Note", short: "TN" }
           end
         end
 
@@ -66,7 +67,7 @@ module Pubid
           super
         end
 
-        private
+        public
 
         def to_short_style
           # Call parent implementation

data/lib/pubid/nist/identifiers.rb

@@ -12,6 +12,7 @@ module Pubid
       autoload :CommercialStandardsMonthly,
                "#{__dir__}/identifiers/commercial_standards_monthly"
       autoload :CrplReport, "#{__dir__}/identifiers/crpl_report"
+      autoload :DatedDocument, "#{__dir__}/identifiers/dated_document"
       autoload :FederalInformationProcessingStandards,
                "#{__dir__}/identifiers/federal_information_processing_standards"
       autoload :GrantContractorReport,

data/lib/pubid/nist/parser.rb

@@ -7,460 +7,26 @@ module Pubid
     # Parser class for NIST identifiers
     # Single Responsibility: Parsing NIST identifier syntax
     class Parser < Parslet::Parser
-      # Class-level parse method with preprocessing
-      # Handles data quality normalization before parsing
-      # Named explicitly to avoid conflict with Parslet's built-in parse method
-      def self.class_parse_with_preprocessing(input)
-        # Apply legacy update_codes normalization first, before any other preprocessing
-        cleaned = Core::UpdateCodes.apply(input.to_s.strip, :nist)
-
-        # Fix lowercase publisher at start
-        cleaned = cleaned.sub(/^nbs\b/i, "NBS")
-        cleaned = cleaned.sub(/^nist\b/i, "NIST")
-
-        # Fix publisher+series concatenation: "NISTIR" → "NIST IR", "NBSIR" → "NBS IR"
-        # Must come after lowercase publisher fix to catch "nistir" → "NISTIR" → "NIST IR"
-        cleaned = cleaned.gsub(
-          /^(NBS|NIST)(IR|FIPS|GCR|HB|MONO|MP|NCSTAR|NSRDS)/i, '\1 \2'
-        )
-
-        # Fix lowercase series (ir, sp, tn, etc.)
-        cleaned = cleaned.sub(/\b(ir|sp|tn|hb|fips|ams|vts)\b/i, &:upcase)
-
-        # Normalize LC to LCIRC (single definition of truth)
-        # Pattern: "LC" followed by space/dot/end should become "LCIRC"
-        # But don't change if already "LCIRC"
-        cleaned = cleaned.gsub(/\bLC\b(?!IRC)/, "LCIRC")
-
-        # Combine "NBS LCIRC" with space into "NBS.LCIRC" ONLY when followed by supplement marker
-        # This allows the circ_supplement_identifier rule to match the pattern
-        # Only apply to supplement cases, not regular LCIRC identifiers
-        cleaned = cleaned.gsub(/\bNBS LCIRC\b(?=.*\b(?:supp?|sup\+|r\d+\/)\d)/,
-                               "NBS.LCIRC")
-
-        # Convert MR format LCIRC supplements to space-separated format
-        # "NBS.LCIRC.145r11/1925" → "NBS LCIRC 145r11/1925" (convert series dot to space)
-        cleaned = cleaned.gsub(/\bNBS\.LCIRC\.(\d+r\d+\/\d{4})/,
-                               "NBS LCIRC \\1")
-        # Also handle without year: "NBS.LCIRC.145r11" → "NBS LCIRC 145r11"
-        cleaned = cleaned.gsub(/\bNBS\.LCIRC\.(\d+r\d+)\b/, "NBS LCIRC \\1")
-
-        # Fix Roman numerals: "1011-I-2" → keep as is, but fix spaces: "1011-I-2 0" → "1011-I-2.0"
-        cleaned = cleaned.gsub(/([-\d]+[IVX]+[-\d]+)\s+(\d+)/, '\1.\2')
-
-        # Fix rev without space: "126rev2013" → "126 rev2013" (separate number from rev+year)
-        # BUT preserve edition+revision patterns: "e2rev1908" stays as-is
-        cleaned = cleaned.gsub(/(?<!e)(\d)(rev\d{4})/, '\1 \2')
-
-        # Fix LCIRC revision with slash and year: "145r6/1925" → "145 r6/1925"
-        # BUT NOT for LCIRC series (keep "NBS LCIRC 145r11/1925" as-is for parser)
-        # The circ_supplement_identifier rule expects "145r11" (no space)
-        unless cleaned.include?("LCIRC") || cleaned.include?("CIRC")
-          cleaned = cleaned.gsub(/(\d)(r\d+\/\d{4})/, '\1 \2')
-        end
-
-        # Fix LCIRC revision with just year (no slash): "1128r1995" → "1128 r1995"
-        # BUT preserve edition+revision patterns: "13e2rev1908" stays as-is
-        # AND preserve month abbreviations in patterns like "107-Mar1985" (ar1985 contains 'r')
-        # Use word boundary to ensure 'r' is standalone, not part of a month name
-        # AND preserve "rv" (revision year) patterns: "1013rv1953" stays as-is
-        cleaned = cleaned.gsub(/\b(r(?!v)\d{4})\b/, ' \1')
-
-        # Fix month in revision: "4743rJun1992" → "4743 rJun1992" (NEW)
-        cleaned = cleaned.gsub(/(\d)(r[A-Z][a-z]{2,8}\d{4})/, '\1 \2')
-        # REMOVED: Revision with 1-2 digits + lowercase letter preprocessing
-        # This is now handled by the more comprehensive fix at lines 131-142
-        # which keeps "22r1a" together (no space) for second_number pattern matching
-
-        # CRITICAL: Normalize lowercase letter suffix to uppercase
-        # Fix dash-letter pattern: "6529-a" → "6529-A" (FIXED - was incorrect)
-        # BUT preserve lowercase for NCSTAR series when letter is followed by volume (e.g., "1-1av1")
-        cleaned = cleaned.gsub(/(\d)-([a-z])$/) { "#{$1}-#{$2.upcase}" }
-
-        # Fix direct letter suffix (no dash): "378g" → "378G", "1000a" → "1000A"
-        # MUST come after dash pattern to avoid conflicts
-        # Fix letter suffix at end: "1011-A" → "1011A", "97-3b" → "97-3B"
-        # CRITICAL: Exclude r+digit pattern (e.g., "73-197r", "6945r") from this conversion
-        # These should remain as lowercase for edition pattern matching
-        # Only match single letter at end, not part of words like "index", "sec", etc.
-        cleaned = cleaned.gsub(/(\d)([a-z&&[^r]])$/) { "#{$1}#{$2.upcase}" }
-        # Also fix r+letter patterns (e.g., "22r1a" → "22r1A") separately
-        cleaned = cleaned.gsub(/(\d)(r)(\d+)([a-z])$/) do
-          "#{$1}#{$2}#{$3}#{$4.upcase}"
-        end
-        # NEW: Fix letter suffix before r (e.g., "53ar1" → "53Ar1")
-        # For patterns like NIST SP 800-53ar1 where letter is between number and revision
-        cleaned = cleaned.gsub(/(\d)([a-z])(r\d)/) { "#{$1}#{$2.upcase}#{$3}" }
-        # NOTE: Removed uppercase letter before r rule - it was breaking 800-56Ar2 parsing
-        # The parser should handle 56Ar2 as a single unit (letter suffix + revision)
-
-        # Fix letter suffix before volume: "1-2bv1" → "1-2Bv1" (MR format)
-        # BUT preserve "rv" (revision year) patterns: "1013rv1953" stays as-is
-        # Skip for NCSTAR to preserve lowercase letters (patterns like "1-1av1" should stay lowercase)
-        is_ncstar = cleaned.include?("NCSTAR")
-        unless is_ncstar
-          cleaned = cleaned.gsub(/(\d)([a-z&&[^r]])(v\d+)/) do
-            "#{$1}#{$2.upcase}#{$3}"
-          end
-        end
-
-        # Fix space before volume number: "80-2073 2" → "80-2073 v2" (Session 219)
-        # This handles NBS IR 80-2073 2 and NBS IR 80-2073 3 as volume identifiers
-        cleaned = cleaned.gsub(/(\d{2}-\d{4})\s+(\d)$/, '\1 v\2')
-
-        # Fix draft with number: "8270-draft2" → "8270 -draft 2" (Session 253)
-        # Space BEFORE dash AND after draft to separate it from report_number
-        cleaned = cleaned.gsub(/(\d)-draft(\d)/, '\1 -draft \2')
-
-        # NEW FIX 2: Draft without dash: "8270draft2" → "8270 -draft 2"
-        # More lenient pattern to catch missing dash before draft
-        cleaned = cleaned.gsub(/(\d)draft(\d)/, '\1 -draft \2')
-
-        # Fix supplement typo: "154suprev" → "154supprev" (Session 219)
-        cleaned = cleaned.gsub(/(\d)suprev/, '\1supprev')
-
-        # Fix letter suffix + revision before draft: "140Cr1-draft2" → "140C r1-draft2" (Session 221)
-        # Must be BEFORE general draft preprocessing at line 47
-        cleaned = cleaned.gsub(/(\d{2,})([A-Z])(r\d+)([-\s]draft\d*)/,
-                               '\1\2 \3\4')
-
-        # Convert Roman numeral volumes to Arabic per NIST spec (page 7)
-        # "1011-I-2.0" → "1011 v1 ver2.0"
-        # "1011-II-1.0" → "1011 v2 ver1.0"
-        cleaned = cleaned.gsub(/(\d+)-([IVX]+)-(\d+(?:\.\d+)*)/) do
-          number = $1
-          roman = $2
-          version_part = $3
-
-          # Convert Roman to Arabic
-          arabic = roman_to_arabic(roman)
-
-          # Convert to volume+version format
-          "#{number} v#{arabic} ver#{version_part}"
-        end
-
-        # Fix LCIRC supplement with slash and year: "118supp3/1926" → "118 supp3/1926"
-        cleaned = cleaned.gsub(/(\d)(supp\d+\/\d{4})/, '\1 \2')
-
-        # Fix Pt pattern: "800-57Pt3r1" → "800-57 pt3 r1"
-        cleaned = cleaned.gsub(/(\d)Pt(\d+)(r\d+)/, '\1 pt\2 \3')
-
-        # Fix version patterns: "ver1e2006" → "ver1 e2006", "ver2v1" → "ver2 v1"
-        cleaned = cleaned.gsub(/(\d)ver(\d)/, '\1 ver \2')
-        cleaned = cleaned.gsub(/ver(\d+)e(\d{4})/, 'ver\1 e\2')
-        cleaned = cleaned.gsub(/ver(\d+)v(\d+)/, 'ver\1 v\2')
-
-        # Fix dotted version: separate from number "268v1.1" → "268 v1.1"
-        cleaned = cleaned.gsub(/(\d)(v\d+\.\d+)/, '\1 \2')
-
-        # CRITICAL: Now separate dotted versions from preceding digits: "268v1.1" → "268 v1.1" (NEW)
-        cleaned = cleaned.gsub(/(\d)(v\d+\.\d+)/, '\1 \2')
-
-        # NEW: Separate version from number AND convert spaces to dots in one step
-        cleaned = cleaned.gsub(/(\d)(v\d+)\s+(\d+)$/, '\1 \2.\3')               # Two-part: "268v1 1" → "268 v1.1"
-        cleaned = cleaned.gsub(/(\d)(v\d+)\s+(\d+)\s+(\d+)$/, '\1 \2.\3.\4')    # Three-part: "63v1 0 1" → "63 v1.0.1"
-
-        # Fix volume ranges: "535v2a-l" → "535 v2a-l", "535v2m-z" → "535 v2m-z"
-        cleaned = cleaned.gsub(/(\d)(v\d+[a-z]-[a-z])/, '\1 \2')
-
-        # NEW: Fix volume with uppercase letter: "48v3B" → "48 v3B" (Session 220)
-        cleaned = cleaned.gsub(/(\d)(v\d+[A-Z])/, '\1 \2')
-
-        # NEW: Fix volume ranges with uppercase: "v2A-L" → "v2a-l" (normalize to lowercase) (Session 220)
-        cleaned = cleaned.gsub(/(v\d+)([A-Z])-([A-Z])/, '\1\2-\3'.downcase)
-
-        # NEW: Fix edition with "ed." suffix: "2006ed." → "e2006" (V1 compatibility)
-        # Pattern appears at end of identifier: "NIST SP 260-162 2006ed."
-        cleaned = cleaned.gsub(/(\d{4})ed\./, 'e\1')
-
-        # CRITICAL: Fix revision attached to number BEFORE update patterns!
-        # "8115r1-upd" → "8115 r1-upd" so that later "r1-upd" → "r1 -upd" works
-        # But preserve r6/1925 format (don't add space before slash/year)
-        # And preserve 300-8r1/upd format (don't separate r1/upd)
-        # ENHANCED: Also handle r1a (revision with letter suffix) - "800-22r1a" → "800-22r1A"
-        # FIXED: When there's a letter suffix, keep together for second_number pattern
-        # CRITICAL: Use \d{1,2} instead of \d+ to limit revision to 1-2 digits, allowing [a-z] to match
-        # First rule: Match r+digit+letter (keep together)
-        cleaned = cleaned.gsub(/(\d+)(r\d{1,2})([a-z])(?=-|[A-Z]|$)/) do
-          num = $1
-          rev = $2
-          letter = $3
-          # Keep together when there's a letter suffix
-          "#{num}#{rev}#{letter.upcase}"
-        end
-        # Second rule: Match r+digit WITHOUT letter suffix
-        # CRITICAL: Use negative lookahead (?![a-zA-Z]) to avoid matching when there's a letter
-        # PRESERVE compact format (no space) when at end of string (NIST SP 800-53r4)
-        # ADD space only when followed by: dash+uppercase, uppercase letter, or /upd, /errata, /insert
-        cleaned = cleaned.gsub(/(\d+)(r\d{1,2})(?![a-zA-Z])(?=[A-Z]|-(?=[A-Z])|\/(?:upd|errata|insert))/) do
-          num = $1
-          rev = $2
-          # Add space when followed by dash+uppercase, uppercase, or update keyword
-          "#{num} #{rev}"
-        end
-
-        # Fix spaces in version/volume numbers: "v1 1" → "v1.1", "1011-I-2 0" → "1011-I-2.0"
-        # ENHANCED to handle multiple spaces: "v1 0 1" → "v1.0.1", "v1 0 2" → "v1.0.2"
-        # FIXED: Pattern must start with "v" or digit to avoid matching "rev 2013" as "v" + " 2013"
-        # CRITICAL: Added word boundary \b to prevent matching "v" within "rev"
-        # CRITICAL FIX: Use \b to ensure match starts at word boundary
-        cleaned = cleaned.gsub(/(\b(?:v|\d)[v\d]*[-A-Z]*)\s+(\d+)(?!(?i:pd|wd|prd)\b)\s+(\d+)(?!(?i:pd|wd|prd)\b)/, '\1.\2.\3') # Three parts
-        # CRITICAL FIX: Use \b to ensure match starts at word boundary.
-        # Negative lookahead: don't swallow the digit of a numeric draft
-        # stage ("189 2pd" must stay split, not become "189.2pd"); letter
-        # stages ("ipd") already don't match the trailing \d+.
-        cleaned = cleaned.gsub(/(\b(?:v|\d)[v\d]*)\s+(\d+)(?!(?i:pd|wd|prd)\b)/, '\1.\2') # Two parts
-
-        # Fix update patterns: ensure space before -upd or /upd (not just at end)
-        # Enhanced to handle optional digits after upd: -upd, -upd1, /upd, /upd1
-        cleaned = cleaned.gsub(/(\d+)-upd(\d*)/, '\1 -upd\2')    # -upd or -upd1
-        cleaned = cleaned.gsub(/(\d+)\/upd(\d*)/, '\1 /upd\2')   # /upd or /upd1
-        cleaned = cleaned.gsub(/([a-z]\d+)-upd/, '\1 -upd')      # r1-upd → r1 -upd
-        cleaned = cleaned.gsub(/([a-z]\d+)\/upd/, '\1 /upd')     # After revision: r1/upd → r1 /upd
-
-        # NEW FIX 3: MR format with letter suffix before update: "8286C-upd1" → "8286C -upd1"
-        # Must handle uppercase letters before -upd in MR format
-        cleaned = cleaned.gsub(/(\d+[A-Z])-upd(\d*)/, '\1 -upd\2')  # Letter suffix + update
-        cleaned = cleaned.gsub(/(\d+[A-Z])\/upd(\d*)/, '\1 /upd\2') # Letter suffix + /upd variant
-
-        # Fix supplement patterns: ensure space before supplement (1st variant)
-        # "118supp3" already handled at line 32-33, but add "sup" variant
-        cleaned = cleaned.gsub(/(\d)(sup\d)/, '\1 \2') # 100-2sup1 → 100-2 sup1
-        # Fix supplement patterns: ensure space before supplement (2nd variant)
-        cleaned = cleaned.gsub(/(\d)(sup+)(\d)/, '\1 \2\3') # 100-2sup+1 → 100-2 sup+1
-        # Fix supplement patterns: ensure space before supplement (3rd variant)
-        cleaned = cleaned.gsub(/(\d)(sup\+)(\d)/, '\1 \2\3') # 100-2sup+1 → 100-2 sup+1
-        # Fix supplement patterns: ensure space before supplement (4th variant)
-        cleaned = cleaned.gsub(/(\d)(sup\d+)/, '\1 \2') # 100-2sup1 → 100-2 sup1
-        # Fix supplement patterns: ensure space before supplement (5th variant)
-        cleaned = cleaned.gsub(/(\d)(sup\d+\b)/, '\1 \2') # 100-2sup1 → 100-2 sup1
-
-        # Fix letter suffix + supplement: "378Gsup" → "378Gsupp" (NEW for LCIRC patterns)
-        # Normalize "sup" to "supp" for letter suffix patterns to match circ_supplement_identifier rule
-        cleaned = cleaned.gsub(/(\d+[A-Z])sup(\b)/, '\1supp\2') # 378Gsup → 378Gsupp
 
-        # Fix LCIRC supplement without letter suffix: "118sup12/1926" → "118supp12/1926"
-        # Normalize "sup" to "supp" for LCIRC patterns to match circ_supplement_identifier rule
-        cleaned = cleaned.gsub(/(\d+)sup(\d+\/\d{4})/, '\1supp\2') # 118sup12/1926 → 118supp12/1926
-
-        # Unify dashed/undashed year supplements: "supp-YYYY" → "suppYYYY".
-        # A bare dash before a 4-digit year is not semantic — "25supp-1924" and
-        # "25supp1924" denote the same publication (the genuine edition marker is
-        # explicit "e", e.g. "25suppe1924"). Collapsing the dash here gives both
-        # spellings ONE parse tree (the normal first_number path), so they build
-        # to an identical Circular with supplement=<year>, with equal ==/URN.
-        # Guard: 4 digits NOT followed by another digit or a slash, so the
-        # dash-slash form "supp-12/1926" (supplement_dash_slash_year) is untouched.
-        cleaned = cleaned.gsub(/(\d)(supp?)-(\d{4})(?![\d\/])/, '\1\2\3') # 25supp-1924 → 25supp1924
-
-        # REMOVED: Revision letter patterns that add space before revision with letter
-        # These conflicted with the fix at lines 131-142 which keeps "22r1a" together
-        # for second_number pattern matching. The comprehensive fix now handles:
-        # - "800-22r1a" → "800-22r1A" (kept together, uppercase letter)
-        # - "800-22r1" → "800-22 r1" (space added when no letter suffix)
-
-        # Fix number with letter suffix followed by standalone 'r': "56ar" → "56a r" (NEW)
-        cleaned = cleaned.gsub(/(\d[a-z])r\b/, '\1 r')
-
-        # Fix revision followed by language code: "r1es" → "r1 es", "r1pt" → "r1 pt" (NEW)
-        cleaned = cleaned.gsub(/(r\d+)(es|pt|chi|viet|port|esp)\b/, '\1 \2')
-
-        # Fix MR format translation codes: ".spa" → " spa", ".por" → " por", ".ind" → " ind" (NEW)
-        # Prevents 3-letter translation codes from being parsed as letter suffixes
-        # "NIST.SP.1262.spa" → "NIST.SP.1262 spa" (convert dot to space)
-        cleaned = cleaned.gsub(/^([A-Z]+)\.SP\.(\d+)\.([a-z]{2,4})$/,
-                               '\1.SP.\2 \3')
-        cleaned = cleaned.gsub(/^([A-Z]+)\.([A-Z]+)\.(\d+)\.([a-z]{2,4})$/,
-                               '\1.\2.\3 \4')
-
-        # ENHANCEMENT 1: Edition year normalization (-YYYY → eYYYY)
-        # Per NIST spec, trailing -YYYY should normalize to eYYYY format
-        # Pattern: number (optionally with non-e letter suffix) followed by dash and 4-digit year
-        # Examples: "330-2019" → "330e2019", "304a-2017" → "304Ae2017"
-        # Must NOT match existing edition patterns like "11e2-1915" (e2 is edition, -1915 is separate)
-        # Must be at end or before space to avoid breaking number-number patterns like "800-53"
-        # Negative lookbehind (?<![eE-]) prevents matching after e/E or dash (avoids e2-1915 and 105-1-1990)
-        # EXCLUSION: Do NOT convert -YYYY for HB series (handbooks) - preserve original format
-        # Example: "NBS HB 130-1979" should stay as "NBS HB 130-1979" (not convert to e1979)
-        # EXCLUSION: Do NOT convert -YYYY when preceded by "e\d+" (edition+year pattern like "44e2-1955")
-        # EXCLUSION: Only convert years in NBS (1901-1988) or NIST (1988-2099) range
-        # Numbers outside this range are part numbers, not edition years (e.g., SP 250-1039)
-        # Use a more specific pattern: only convert when NOT preceded by "e" + digits (edition)
-        # AND only convert when year is in valid range (1901-2099)
-        cleaned = cleaned.gsub(/(?<!e\d)(?<![eE-])(\d(?:[A-DF-Z]?))-(\d{4})(?=\s|$)/) do |match|
-          prefix = $1 # Number with optional letter
-          year = $2.to_i
-          # Only convert to edition format if year is in valid range
-          if year.between?(1901, 2099)
-            "#{prefix}e#{year}"
-          else
-            match # Keep dash format for part numbers (e.g., 250-1039)
-          end
-        end
-        # Revert the conversion for HB series to preserve -YYYY format
-        # Matches both "HB 130e1979" and "HB 105-1e1990" patterns
-        # Use [^:\s.]*? (exclude dots) to avoid consuming MR format dot separators
-        # This prevents "NIST.HB.135e2022" from being incorrectly reverted
-        cleaned = cleaned.gsub(/\b(HB|HB\s+)[^:\s.]*?(\d+)e(\d{4})(?=\s|$)/,
-                               '\1\2-\3')
-        # Revert the conversion for OWMWP series to preserve date format MM-DD-YYYY
-        # OWMWP uses date as the number: "06-13-2018" (not an edition)
-        # Pattern: "OWMWP 06-13e2018" → "OWMWP 06-13-2018"
-        cleaned = cleaned.gsub(
-          /\b(OWMWP|OWMWP\s*)[^:\s]*?(\d{2})-(\d{2})e(\d{4})(?=\s|$)/, '\1\2-\3-\4'
-        )
-        # Revert the conversion for RPT series to preserve year range format YYYY-YYYY
-        # Report series uses year ranges as the number: "1946-1947" (not an edition)
-        # Pattern: "RPT 1946e1947" → "RPT 1946-1947"
-        # Note: This must check that first year < second year (forward range)
-        cleaned = cleaned.gsub(/\b(RPT|RPT\s*)([^:\s]*?)(\d{4})e(\d{4})(?=\s|$)/) do |match|
-          prefix = $1 # "RPT" or "RPT "
-          separator = $2 # "." or "" or other non-colon, non-space chars
-          first_year = $3.to_i
-          second_year = $4.to_i
-          # Only revert if first < second (year range like 1946-1947)
-          if first_year < second_year
-            "#{prefix}#{separator}#{first_year}-#{second_year}"
-          else
-            match # Keep e format for editions like e2018e2019
-          end
-        end
-
-        # ENHANCEMENT 2: Version normalization (v1.1 → ver1.1, Ver. 2.0 → ver2.0)
-        # Normalize short v format to verbose ver format per NIST spec
-        # Already handled in version rule, but normalize in preprocessing for consistency
-
-        # CRITICAL: MR format version normalization must come BEFORE general v normalization
-        # Pattern: "NIST.SP.500-281-v1.0" → "NIST.SP.500-281.ver1.0"
-        # This allows report_number to match "500-281" and version rule to match ".ver1.0"
-        cleaned = cleaned.gsub(/-v(\d+\.\d+)/, '.ver\1')
-
-        # Handle Ver. with period: "Ver. 2.0" → "ver2.0" (remove period and space)
-        cleaned = cleaned.gsub(/\bVer\.\s+(\d+(?:\.\d+)*)/, 'ver\1')
-        # Handle verbose "v" to "ver": "v1.1" → "ver1.1" (only with dots - versions have dots)
-        cleaned = cleaned.gsub(/\bv(\d+\.\d+(?:\.\d+)*)/, 'ver\1')
-
-        # Fix uppercase P for part: "428P1" → "428 p1", "647P2" → "647 p2" (NEW)
-        cleaned = cleaned.gsub(/(\d)P(\d)/, '\1 p\2')
-
-        # Normalize part notation: "p1" → "pt1", "n1" → "pt1" for consistency
-        # This handles patterns like "61p1" → "61pt1" and "467n1" → "467pt1"
-        # MUST come AFTER uppercase P normalization
-        # EXCLUDE pattern: {number}p{digit}{4-digit-year} like "28p11969" (part + year, not part notation)
-        # Use negative lookahead to avoid matching when p/n + digit is followed by exactly 4 digits (year)
-        cleaned = cleaned.gsub(/\b([pn])(\d+)(?!\d{4}\b)/, 'pt\2')
-
-        # Fix complex part patterns in MR format: ensure space before part
-        cleaned = cleaned.gsub(/(\d)([pP]\d+)/, '\1 \2') # .467p1adde1 → .467 p1adde1, 800-57p1 → 800-57 p1
-
-        # Fix CRPL-F series: ensure space after series (e.g., "CRPL-F-B150" → "CRPL-F-B 150")
-        cleaned = cleaned.gsub(/(NBS CRPL-F-[AB])(\d)/, '\1 \2')
-        cleaned = cleaned.gsub(/(CRPL-F-[AB])(\d)/, '\1 \2')
-
-        # Extract volume from number: "17-917v3" → "17-917 v3", "1-1v1" → "1-1 v1"
-        # Pattern: digits-digits followed by v and digits (GCR, NCSTAR patterns)
-        # MUST be specific to avoid breaking existing "v1.1" patterns
-        cleaned = cleaned.gsub(/(\d+-\d+)(v\d+)(?![.\d])/, '\1 \2') # Negative lookahead for dots
-
-        # pd_suffix rule handles " 2pd" directly (space >> digits >> str("pd"))
-        # No preprocessing needed - adding space before "pd" breaks the parser
-
-        # Fix "Suppl" with space: "955 Suppl" → "955Suppl"
-        cleaned = cleaned.gsub(/(\d+)\s+Suppl\b/, '\1Suppl')
-
-        # Fix verbose "Version" format: " Version 2" → " ver 2"
-        cleaned = cleaned.gsub(/\s+Version\s+(\d+)/, ' ver \1')
-
-        # Fix verbose "Revision" format: " Revision (r)" → " r"
-        cleaned = cleaned.gsub(/\s+Revision\s+\(r\)/, " r")
-
-        # Fix verbose "Part N" → short "ptN": "800-57 Part 2 Rev. 1" →
-        # "800-57pt2 Rev. 1". The grammar already accepts short "ptN" (and
-        # "ptN Rev. M"); only the verbose spelling was unsupported. Attaches
-        # to the preceding number so the existing part rule applies.
-        cleaned = cleaned.gsub(/\s+Part\s+(\d+)/, 'pt\1')
-
-        # Normalize verbose addendum " Add"/" add" (with or without period)
-        # to the canonical " Add." the grammar accepts, and uppercase a
-        # doc-number letter that immediately precedes it ("800-38a Add" →
-        # "800-38A Add.") — NIST doc-number letters are canonically uppercase
-        # and the letter_number grammar rule only splits the uppercase form.
-        # Scoped to the addendum context so bare markers like "800-90r"
-        # (revision) are left untouched.
-        cleaned = cleaned.gsub(/(\d[a-z]?)\s+Add\b\.?/i) { "#{Regexp.last_match(1).upcase} Add." }
-
-        # Fix verbose "rev YYYY" format: "126 rev 2013" → "126r2013"
-        # Removes space between number and "rev", and converts to "r" prefix
-        # Handles patterns like "NIST SP 260-126 rev 2013" → "NIST SP 260-126r2013"
-        cleaned = cleaned.gsub(/(\d+)\s+rev\s+(\d{4})/, '\1r\2')
-
-        # Fix historical "report ;" format: "NBS report ; 8079" → "NBS RPT 8079"
-        # The semicolon and "report" (spelled out) are historical formats
-        cleaned = cleaned.gsub(/\breport\s*;\s*/, "RPT ")
-        cleaned = cleaned.gsub(/\breport\b/, "RPT")
-
-        # REMOVED: Incorrect dot preprocessing that treated dots as number separators
-        # This was semantically wrong - dots are PART separators in NIST!
-        # DELETE: cleaned = cleaned.gsub(/(\d{3,})\.(\d{1,4})(?=\s|$)/, '\1_\2')
-
-        # REMOVED: Incorrect space-to-underscore that treated as single number
-        # DELETE: cleaned = cleaned.gsub(/(\d{3,})\s+(\d{1,2})$/, '\1_\2')
-
-        # Detect format before parsing
-        format = detect_format(input.to_s)
-
-        # Use parslet parser instance
-        result = new.parse(cleaned)
+      # Class-level parse method with preprocessing.
+      # Delegates all string normalization to Nist::Preprocessor, then
+      # feeds the cleaned string to the Parslet grammar and stamps the
+      # detected format onto the parse tree.
+      def self.class_parse_with_preprocessing(input)
+        result = Preprocessor.new(input).call
+        parsed = new.parse(result.cleaned)
 
-        # Add format to result
-        if result.is_a?(Hash)
-          result.merge(parsed_format: format)
-        elsif result.is_a?(Array)
-          # For array results, merge all hashes into one
-          # This handles cases where identifier rule returns multiple components (e.g., compound_series + edition)
-          merged = result.inject({}) do |acc, hash|
+        if parsed.is_a?(Hash)
+          parsed.merge(parsed_format: result.format)
+        elsif parsed.is_a?(Array)
+          merged = parsed.each_with_object({}) do |hash, acc|
             next acc unless hash.is_a?(Hash)
 
-            acc.merge(hash)
+            acc.merge!(hash)
           end
-          merged.merge(parsed_format: format)
-        else
-          result
-        end
-      end
-
-      # Detect format from input string
-      # :mr if contains dots (machine-readable: NIST.SP.800-53)
-      # :short otherwise (default: NIST SP 800-53)
-      def self.detect_format(input)
-        # Check if it has dot separators (MR format pattern)
-        # Patterns include:
-        # - "NIST.SP.800-53" (publisher.series.number)
-        # - "FIPS.46e1977" (series.numberWithEdition)
-        # - "NBS.HB.28pt1e1969" (publisher.series.part.edition)
-        # Key indicator: dots between components instead of spaces
-        if input.include?(".") && !input.match?(/\s/)
-          :mr
+          merged.merge(parsed_format: result.format)
         else
-          :short
-        end
-      end
-
-      # Convert Roman numerals to Arabic numbers
-      # I→1, II→2, III→3, IV→4, V→5, VI→6, VII→7, VIII→8, IX→9, X→10
-      def self.roman_to_arabic(roman)
-        case roman
-        when "I" then "1"
-        when "II" then "2"
-        when "III" then "3"
-        when "IV" then "4"
-        when "V" then "5"
-        when "VI" then "6"
-        when "VII" then "7"
-        when "VIII" then "8"
-        when "IX" then "9"
-        when "X" then "10"
-        else roman # Fallback for unexpected patterns
+          parsed
         end
       end
 
@@ -650,6 +216,14 @@ module Pubid
           # Note: Preprocessing converts content inside parentheses to uppercase
           # Use specific patterns to avoid consuming other parenthetical content
           (digits.as(:number) >> str("(") >> (str("SP") | str("PT") | str("ES")).as(:language_code) >> str(")")) |
+          # Number with letter suffix followed by revision (e.g., "8278Ar1", "256Ar1930")
+          # CRITICAL: Must come BEFORE digits_with_suffix because number_suffix's
+          # str("r").absent? guard rejects any letter followed by 'r' (would
+          # otherwise drop the letter and parse "256" + "Ar1930" as garbage).
+          (digits.as(:number) >>
+           upper_letter.as(:letter_suffix) >>
+           str("r") >>
+           digits.as(:revision_id)).as(:number_with_letter_revision) |
           # Regular number with optional suffix (original) - includes letters like "A"
           digits_with_suffix
         ).as(:first_number)
@@ -754,6 +328,22 @@ module Pubid
         ).as(:date)
       end
 
+      # ISO date token (YYYY-MM-DD) for date-style identifiers
+      rule(:iso_date) do
+        (match("[0-9]").repeat(4, 4).as(:date_year) >> dash >>
+         match("[0-9]").repeat(2, 2).as(:date_month) >> dash >>
+         match("[0-9]").repeat(2, 2).as(:date_day))
+      end
+
+      # Date-style identifier with no series (e.g. "NIST 2022-04-15 001",
+      # "NIST.2022-04-15.001" — DOI 10.6028/NIST.2022-04-15.001)
+      rule(:dated_identifier) do
+        hash_prefix.maybe >>
+          publisher >> (space | dot) >>
+          iso_date.as(:dated_date) >> (space | dot) >>
+          match("[0-9]").repeat(1).as(:dated_seq)
+      end
+
       # LEGACY EDITION PATTERNS (for backward compatibility during migration)
       # These will be gradually replaced as we migrate to proper Edition/Date components
       rule(:legacy_edition) do
@@ -790,6 +380,8 @@ module Pubid
       rule(:report_number) do
         first_number >>
           (
+            # Underscore edition-year (space-form mirror of mr_identifier): "1648_2009"
+            (str("_") >> digits.as(:edition_year)) |
             # Month abbreviation as edition (e.g., 107-Mar1985, 11-Jan1925)
             # MUST BE FIRST to catch -MonthYear patterns before they're
             # incorrectly parsed as other alternatives
@@ -809,6 +401,13 @@ module Pubid
               (str("U") >> lower_letter.as(:letter_suffix_extra)) |
               upper_letter
             ).as(:letter_suffix)).as(:letter_number) |
+            # Dash-SEPARATED letter suffix on a numbered part (e.g., 21-4-B,
+            # 173-1-B for FIPS, and the reparseable form of letter_number's own
+            # rendered output 200-30-B). The month_abbrev guard keeps FIPS date
+            # forms like 11-1-Sep1977 with the earlier patterns; the trailing
+            # guard restricts to a single clean letter so GCR -200-30B is unaffected.
+            (dash >> digits.as(:letter_base) >> dash >> month_abbrev.absent? >>
+             upper_letter.as(:letter_suffix) >> (letter | digit).absent?).as(:letter_number) |
             # Edition dash-year pattern (e.g., -1979 for handbooks like "NBS HB 130-1979")
             # Matches any 4-digit sequence - the builder decides if it's a year or second_number
             (dash >> match("[0-9]").repeat(4,
@@ -908,8 +507,18 @@ module Pubid
           (
             digits.as(:update_number).maybe >>
             (dash >>
-              match("[0-9]").repeat(4, 4).as(:update_year) >>
-              match("[0-9]").repeat(2, 2).as(:update_month).maybe
+              (
+                # Real updates: 4-digit year + optional 2-digit month
+                # (e.g. /Upd1-2015, /Upd3-202102).
+                (match("[0-9]").repeat(4, 4).as(:update_year) >>
+                 match("[0-9]").repeat(2, 2).as(:update_month)) |
+                # Fallback: capture the whole digit run as the year. Handles the
+                # unpadded CIRC/LCIRC supplement form pubid emits, where year and
+                # revision are fused without a 2-digit month boundary
+                # (e.g. /Upd1-19256 = 1925 + revision 6). Keeps these strings
+                # re-parseable so generated ids round-trip.
+                match("[0-9]").repeat(4).as(:update_year)
+              )
             ).maybe
           ).as(:update)
       end
@@ -974,8 +583,8 @@ module Pubid
         (str("(") >> match('\w').repeat(3, 3).as(:translation) >> str(")")) |
           # Space-prefix format: " spa"
           (space >> match('\w').repeat(3, 3).as(:translation)) |
-          # Dot-prefix format: ".spa" (machine-readable)
-          (dot >> match('\w').repeat(3, 3).as(:translation))
+          # Dot-prefix format: ".spa" (machine-readable), optional leading space: " .spa"
+          (space.maybe >> dot >> match('\w').repeat(3, 3).as(:translation))
       end
 
       # Public draft suffix - for patterns like 2pd, 3pd
@@ -1043,6 +652,7 @@ module Pubid
       # Try compound series first (longest match), then publisher + simple series
       rule(:identifier) do
         circ_supplement_identifier |
+          dated_identifier |
           mr_identifier |
           (
             # Compound series (includes publisher in series name)