relaton 3.0.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/relaton/etsi/data_fetcher.rb

@@ -11,13 +11,21 @@ module Relaton
     class DataFetcher < Core::DataFetcher
       PAGE_SIZE = 50
 
+      # `version=1` keeps the superseded EDITIONS of a document in the result
+      # set; `version=0` returns only the current edition of each branch. The
+      # status flags below are a separate axis and already permissive, so this
+      # is what makes e.g. all three editions of `ETSI EN 319 142-1` retrievable
+      # instead of one. It also makes the crawl about 2.4 times larger — see
+      # lib/relaton/etsi/CLAUDE.md before changing it back.
       SOURCEURL = "https://www.etsi.org/custom/standardssearch/data.php?format=json&includeScope=1&" \
-        "page=%<page>s&search=&title=1&etsiNumber=1&content=1&version=0&onApproval=1&published=1&" \
+        "page=%<page>s&search=&title=1&etsiNumber=1&content=1&version=1&onApproval=1&published=1&" \
         "withdrawn=1&historical=1&isCurrent=1&superseded=1&startDate=1988-01-15&endDate=%<date>s&" \
         "harmonized=0&keyword=&TB=&stdType=&frequency=&mandate=&collection=&sort=1&x=%<timestamp>s".freeze
 
       def index
-        @index ||= Relaton::Index.find_or_create :etsi, file: INDEX_FILE
+        @index ||= Relaton::Index.find_or_create(
+          :etsi, file: "#{INDEXFILE}.yaml", pubid_class: ::Pubid::Etsi::Identifier
+        )
       end
 
       def log_error(msg)
@@ -107,9 +115,40 @@ module Relaton
 
       def save(bib)
         id = bib.docidentifier.first.content
-        file = output_file id
+        pid = pubid(id) or return # skip ids pubid can't parse/serialize
+
+        # Distinct docids can sanitize to one filename (`output_file` collapses
+        # `/`, `-`, `.`, `:` and `()` alike, and ETSI ids use all of them), which
+        # used to overwrite silently. Take a path of our own. There is no @files
+        # here, so a repeat of the SAME id still resolves to one path and
+        # overwrites itself, as before.
+        file = unique_output_file id
+        if file != output_file(id)
+          Util.warn "File #{output_file id} already exists. Docid: #{id}. Writing #{file} instead."
+        end
         File.write file, serialize(bib), encoding: "UTF-8"
-        index.add_or_update id, file
+        index.add_or_update pid, file
+      end
+
+      #
+      # Parse an ETSI docid into a Pubid::Etsi identifier, or nil when it can't
+      # be parsed or serialized. Storing the pubid object (not its hash) lets
+      # Relaton::Index sort the index by id number and serialize each id to its
+      # `_type: pubid:etsi:*` hash on save. A single unindexable id must never
+      # abort the crawl or corrupt the index, so it is skipped defensively
+      # (mirrors Relaton::Nist#pubid / Relaton::Jcgm#add_to_index). ETSI's whole
+      # published corpus parses on the pinned pubid; the guard protects against a
+      # future malformed record.
+      #
+      # @param [String] id docidentifier content, e.g. "ETSI GS ZSM 012 V1.1.1 (2022-12)"
+      # @return [::Pubid::Etsi::Identifier, nil]
+      #
+      def pubid(id)
+        pid = ::Pubid::Etsi.parse id
+        pid.to_hash # skip ids whose to_hash raises so index.save can't fail
+        pid
+      rescue StandardError
+        nil
       end
 
       def to_yaml(bib)

data/lib/relaton/etsi/processor.rb

@@ -62,7 +62,9 @@ module Relaton
       #
       def remove_index_file
         require_relative "../etsi"
-        Relaton::Index.find_or_create(:etsi, url: true, file: INDEX_FILE).remove_file
+        Relaton::Index.find_or_create(
+          :etsi, url: true, file: "#{INDEXFILE}.yaml"
+        ).remove_file
       end
     end
   end

data/lib/relaton/etsi.rb

@@ -2,6 +2,7 @@
 
 require "net/http"
 require "mechanize"
+require "pubid"
 require "relaton/index"
 require_relative "version"
 # require_relative "relaton_etsi/pubid"
@@ -12,7 +13,7 @@ require_relative "etsi/bibliography"
 
 module Relaton
   module Etsi
-    INDEX_FILE = "index-v1.yaml"
+    INDEXFILE = "index-v2".freeze
 
     # Returns hash of gem versions used to generate data model.
     # @return [String]

data/lib/relaton/gb/bibliography.rb

@@ -40,19 +40,16 @@ module Relaton
         # @param code [String] the GB standard Code to look up (e..g "GB/T 20223")
         # @param year [String] the year the standard was published (optional)
         # @param opts [Hash] options; restricted to :all_parts if all-parts reference is required
-        # @return [String] Relaton XML serialisation of reference
-        def get(code, year = nil, opts = {}) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          if year.nil?
-            /^(?<code1>[^-]+)-(?<year1>[^-]+)$/ =~ code
-            unless code1.nil?
-              code = code1
-              year = year1
-            end
-          end
-
-          code += ".1" if opts[:all_parts]
-          code, year = code.split("-", 2) if code.include?("-")
-          ret = get1(code, year, opts)
+        # @return [Relaton::Gb::ItemData, nil]
+        # @raise [Pubid::Errors::ParseError] when the code is not a GB
+        #   identifier
+        def get(code, year = nil, opts = {})
+          require "pubid"
+          pubid = ::Pubid::Gb::Identifier.parse(code)
+          year = (year || pubid.year)&.to_s
+          pubid = pubid.exclude(:year)
+          pubid.part = "1" if opts[:all_parts]
+          ret = get1(pubid, year, opts)
           return nil if ret.nil?
 
           ret = ret.to_most_recent_reference unless year
@@ -62,49 +59,78 @@ module Relaton
 
         private
 
-        def fetch_ref_err(code, year, missed_years) # rubocop:disable Metrics/MethodLength
-          # id = year ? "#{code}:#{year}" : code
-          # Util.info "WARNING: No match found on the GB website for `#{id}`. " \
-          #           "The code must be exactly like it is on the website."
+        # @param pubid [Pubid::Gb::Identifier] the reference without a year
+        def fetch_ref_err(pubid, year, missed_years) # rubocop:disable Metrics/MethodLength
           unless missed_years.empty?
             Util.info "(There was no match for `#{year}`, though there " \
                       "were matches found for `#{missed_years.join('`, `')}`.)"
           end
-          if /\d-\d/.match? code
+          if pubid.part
             Util.info "The provided document part may not exist, or " \
                       "the document may no longer be published in parts."
           else
             Util.info "If you wanted to cite all document parts for the " \
-                      "reference, use `#{code} (all parts)`.\nIf the document " \
+                      "reference, use `#{pubid} (all parts)`.\nIf the document " \
                       "is not a standard, use its document type abbreviation " \
                       "(TS, TR, PAS, Guide)."
           end
           nil
         end
 
-        def get1(code, year, _opts)
+        # @param pubid [Pubid::Gb::Identifier] the reference without a year
+        # @param year [String, nil]
+        def get1(pubid, year, _opts)
           # search must include year whenever available
-          searchcode = code + (year.nil? ? "" : "-#{year}")
-          result = search_filter(searchcode) || return
+          query = with_year(pubid, year)
+          searchcode = query.to_s
+          result = search_filter(query) || return
           ret = results_filter(result, year)
           if ret[:ret]
             Util.info "Found: `#{ret[:ret].docidentifier.first.content}`", key: searchcode
             ret[:ret]
           else
             Util.info "Not found.", key: searchcode
-            fetch_ref_err(code, year, ret[:years])
+            fetch_ref_err(pubid, year, ret[:years])
           end
         end
 
-        def search_filter(code)
-          # search filter needs to incorporate year
-          docidrx = %r{^[^\s]+\s[\d.-]+}
-          result = search(code)
-          result.select! do |hit|
-            hit.docref && hit.docref.match(docidrx).to_s.include?(code)
+        # @param pubid [Pubid::Gb::Identifier]
+        # @param year [String, nil]
+        # @return [Pubid::Gb::Identifier] a copy of pubid that carries the year
+        def with_year(pubid, year)
+          return pubid unless year
+
+          dated = pubid.exclude
+          dated.date = ::Pubid::Components::Date.new(year: year)
+          dated
+        end
+
+        # Keeps the hits that name the queried document. A query with no year
+        # matches every year. A query with no part matches only the part-less
+        # document: in GB, `GB/T 20223` and `GB/T 20223.1` are two documents.
+        #
+        # @param query [Pubid::Gb::Identifier]
+        # @return [Relaton::Gb::HitCollection, nil]
+        def search_filter(query)
+          ignore = query.year ? [] : %i[year]
+          result = search(query.to_s)
+          result&.select! do |hit|
+            hit_pubid = parse_docref(hit.docref)
+            hit_pubid && query.matches?(hit_pubid, ignore: ignore)
           end
         end
 
+        # A portal docref is data, so a value pubid cannot read is nil and
+        # drops the hit.
+        #
+        # @param docref [String, nil]
+        # @return [Pubid::Gb::Identifier, nil]
+        def parse_docref(docref)
+          ::Pubid::Gb::Identifier.parse(docref) if docref
+        rescue StandardError
+          nil
+        end
+
         # Sort through the results from Isobib, fetching them three at a time,
         # and return the first result that matches the code,
         # matches the year (if provided), and which # has a title (amendments do

data/lib/relaton/gb/docidentifier.rb

@@ -1,22 +1,71 @@
 module Relaton
   module Gb
+    # A Chinese Standard identifier backed by `Pubid::Gb`.
+    #
+    # `content` stays a plain string, so serialization is unchanged; the parsed
+    # identifier lives beside it in `@pubid` and drives the three mutators.
+    # Follows the IALA, CEN and OMG shape (`lib/relaton/iala/docidentifier.rb`,
+    # `lib/relaton/cen/model/docidentifier.rb`).
     class Docidentifier < Bib::Docidentifier
-      def content
-        @all_parts ? "#{super} (all parts)" : super
-      end
+      # @return [Pubid::Gb::Identifier, nil] nil when the content is not a GB
+      #   identifier, or the grammar cannot read it
+      attr_reader :pubid
 
-      def to_all_parts!
-        remove_part!
-        remove_date!
-        @all_parts = true
+      # Capture the inherited (LocalizedMarkedUpString) content setter before
+      # overriding #content=, so #replace_pubid writes the re-rendered string
+      # back WITHOUT re-parsing it and discarding the mutation.
+      alias_method :store_content, :content=
+
+      def content=(value)
+        super
+        return unless value
+
+        @pubid = begin
+          # `pubid` is required lazily because deserialization reaches this
+          # class without the flavor entry file having been loaded. LoadError
+          # degrades to a plain string; StandardError covers a value that is
+          # not a GB identifier. Both are DATA and must not raise. A malformed
+          # *query* raises — see Bibliography.get.
+          require "pubid"
+          ::Pubid::Gb::Identifier.parse(value)
+        rescue LoadError, StandardError
+          nil
+        end
       end
 
       def remove_part!
-        content.sub!(/\.\d+/, "")
+        return unless @pubid
+
+        replace_pubid @pubid.exclude(:part)
       end
 
       def remove_date!
-        content.sub!(/-\d{4}$/, "")
+        return unless @pubid
+
+        replace_pubid @pubid.exclude(:year)
+      end
+
+      # Strips the part and the date, then wraps the identifier in pubid's
+      # `AllParts`. `Pubid::Gb::Identifiers::AllParts` renders the
+      # ` (all parts)` marker itself and parses the form back, so — unlike CEN
+      # and BSI, whose renderers have no marker — `content` is the wrapper's
+      # own string (`GB/T 5606 (all parts)`, which
+      # `spec/gb/fixtures/gbt_5606_2004_all_parts.xml` asserts).
+      #
+      # The guard keeps a second call from doubling the marker.
+      def to_all_parts!
+        return if !@pubid || @pubid.all_parts?
+
+        replace_pubid @pubid.exclude(:part, :year).to_all_parts
+      end
+
+      private
+
+      # `Pubid#exclude` returns a COPY, so the new identifier replaces the old
+      # one.
+      def replace_pubid(new_pubid)
+        @pubid = new_pubid
+        store_content @pubid.to_s
       end
     end
   end

data/lib/relaton/gb/processor.rb

@@ -8,6 +8,9 @@ module Relaton
       def initialize
         @short = :relaton_gb
         @prefix = "CN"
+        # Global prefixes come from Pubid::Gb.prefixes. "CN" is not one of
+        # them, so it leaves the register; routing still reads @prefix.
+        @pubid_flavor = :Gb
         @defaultprefix = %r{^(GB|GB/T|GB/Z) }
         @idtype = "Chinese Standard"
       end

data/lib/relaton/gb/scraper.rb

@@ -45,8 +45,7 @@ module Relaton
       # @param docref [Strings]
       # @return [Array<Relaton::Bib::Contributor>]
       def get_contributors(doc, docref)
-        name = docref.match(/^[^\s]+/).to_s
-        name.sub!(%r{/[TZ]$}, "") unless name =~ /^GB/
+        name = docref_pubid(docref)&.publisher&.to_s
         gbtype = get_gbtype(doc, docref)
         org_names = %w[en zh].map { |l| create_org_name(l, name, gbtype) }.compact
         return [] unless org_names.any?
@@ -120,11 +119,14 @@ module Relaton
         end
       end
 
+      # The publisher of a social group standard names the group
+      # (`T/GZAEPI`), so only its first segment keys `yaml/prefixes.yaml`.
+      #
       # @param ref [String]
-      # @return [String]
+      # @return [Hash{String=>String}, nil]
       def get_prefix(ref)
-        pref = ref.match(/^[^\s]+/).to_s.split("/").first
-        prefix pref
+        pref = docref_pubid(ref)&.publisher&.to_s
+        prefix pref.split("/").first if pref
       end
 
       # @param pref [String]
@@ -137,7 +139,7 @@ module Relaton
       # @param ref [String]
       # @return [String]
       def get_mandate(ref)
-        case ref.match(%r{(?<=\/)[^\s]+}).to_s
+        case docref_pubid(ref)&.mandate
         when "T" then "recommended"
         when "Z" then "guidelines"
         else "mandatory"
@@ -180,14 +182,29 @@ module Relaton
       # @return [Relaton::Gb::GbType]
       def get_gbtype(doc, ref)
         # ref = get_ref(doc)
-        GbType.new(scope: get_scope(doc), prefix: get_prefix(ref)["prefix"], mandate: get_mandate(ref), topic: "other")
+        GbType.new(scope: get_scope(doc), prefix: get_prefix(ref)&.fetch("prefix", nil), mandate: get_mandate(ref), topic: "other")
       end
 
+      # A portal docref is data, so a value pubid cannot read is nil rather
+      # than an error.
+      #
       # @param docref [String]
-      # @return [Array<String>] array of matched groups [docnumber, partnumber]
+      # @return [Pubid::Gb::Identifier, nil]
+      def docref_pubid(docref)
+        require "pubid"
+        ::Pubid::Gb::Identifier.parse(docref)
+      rescue StandardError
+        nil
+      end
+
+      # @param docref [String]
+      # @return [Array<String, nil>] the id without part and year (e.g.
+      #   `GB/T 5606`), the part, and the year
       def parse_docref(docref)
-        m = docref.match(/^([^–—.-]*\d+)\.?((?<=\.)\d+|)(?:-(\d{4}))?/)
-        [m[1], m[2], m[3]]
+        pubid = docref_pubid(docref)
+        return [docref, nil, nil] unless pubid
+
+        [pubid.exclude(:part, :year).to_s, pubid.part, pubid.year]
       end
 
       # @param docref [String]

data/lib/relaton/gost/bibdata.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Gost
+    class Bibdata < Item
+      model ItemData
+      include Bib::BibdataShared
+    end
+  end
+end

data/lib/relaton/gost/bibitem.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Gost
+    class Bibitem < Item
+      model ItemData
+      include Bib::BibitemShared
+    end
+  end
+end

data/lib/relaton/gost/bibliography.rb

@@ -0,0 +1,107 @@
+require "net/http"
+
+module Relaton
+  module Gost
+    # Retrieval front-end for the GOST flavor. Parses the citation with
+    # Pubid::Gost, looks it up in the pubid-structured `relaton-data-gost`
+    # index-v2, and fetches the matching per-document YAML over HTTP.
+    #
+    # The index rows are keyed by Pubid::Gost identifiers (`_type: pubid:gost:
+    # {interstate,national}-standard`, number, year), so `Relaton::Index`
+    # narrows candidates by number via binary search before the block applies
+    # the precise pubid match. Both Latin "GOST"/"GOST R" and Cyrillic
+    # "ГОСТ"/"ГОСТ Р" surface forms parse (Pubid normalises Cyrillic to Latin).
+    module Bibliography
+      ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-gost/main/".freeze
+
+      class << self
+        # Search for a GOST publication by its identifier.
+        #
+        # @param text [String, Pubid::Gost::Identifier] the GOST reference to
+        #   look up (e.g. "GOST R 34.12-2015", "GOST 14946-82", "ГОСТ 1.0")
+        # @param year [String, nil] the edition year (optional; may also be
+        #   embedded in the reference)
+        # @param _opts [Hash] options (unused)
+        # @return [Relaton::Gost::Item, nil]
+        def search(text, year = nil, _opts = {})
+          pubid = text.is_a?(String) ? ::Pubid::Gost.parse(text) : text
+          Util.info "Fetching from Relaton repository ...", key: pubid.to_s
+          # Pass the pubid so Relaton::Index narrows candidates by number via
+          # binary search; pick the latest edition for an undated citation.
+          row = rows(pubid, year).max_by { |r| r[:id].year.to_i }
+          unless row
+            Util.info "Not found.", key: pubid.to_s
+            return
+          end
+
+          uri = URI("#{ENDPOINT}#{row[:file]}")
+          resp = Net::HTTP.get_response uri
+          unless resp.code == "200"
+            raise Relaton::RequestError, "Could not access #{uri}: HTTP #{resp.code}"
+          end
+
+          item = Relaton::Gost::Item.from_yaml resp.body
+          Util.info "Found: `#{item.docidentifier.first&.content}`", key: pubid.to_s
+          item.tap { |i| i.fetched = Date.today.to_s }
+        rescue SocketError, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+               Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+               Net::ProtocolError, Net::ReadTimeout, OpenSSL::SSL::SSLError,
+               Errno::ETIMEDOUT => e
+          raise Relaton::RequestError, "Could not access #{uri}: #{e.message}"
+        end
+
+        # Fetch a GOST publication, suppressing the edition year for an undated
+        # citation so the designation renders undated (`GOST R 34.12`), the way
+        # the ISO/OIML fetchers do. A dated citation (`GOST R 34.12-2015`, or an
+        # explicit `year`) still pins that edition.
+        #
+        # @param opts [Hash] options
+        # @option opts [Boolean] :keep_year retain the edition year even for an
+        #   undated citation (or, when false, strip it even for a dated one)
+        # @see #search
+        def get(ref, year = nil, opts = {})
+          item = search(ref, year, opts)
+          return item unless item
+
+          pubid = ref.is_a?(String) ? ::Pubid::Gost.parse(ref) : ref
+          dated = pubid.year || year
+          return item if (dated && opts[:keep_year].nil?) || opts[:keep_year]
+
+          item.to_most_recent_reference
+        end
+
+        private
+
+        def index
+          Relaton::Index.find_or_create(
+            :gost,
+            url: "#{ENDPOINT}#{INDEXFILE}.zip",
+            file: "#{INDEXFILE}.yaml",
+            pubid_class: ::Pubid::Gost::Identifier,
+          )
+        end
+
+        # The index rows for a citation. A dated citation matches exactly
+        # (`exact: true`, pubid `==`). An undated one takes pubid's subset
+        # match `query === row`, so it matches every edition of the document:
+        # the omitted year matches any value. The class must be identical, so
+        # interstate and national standards stay distinct, and `1.1` does not
+        # match `1.10`. pubid declares `copublisher` strict for GOST, so an
+        # omitted copublisher means "none". The `year` argument pins an edition
+        # the reference string omitted.
+        #
+        # @param query [Pubid::Gost::Identifier]
+        # @param year [String, nil]
+        # @return [Array<Hash>]
+        def rows(query, year)
+          return index.search(query, exact: true) if query.year
+
+          rows = index.search(query)
+          return rows unless year
+
+          rows.select { |r| r[:id].year.to_s == year.to_s }
+        end
+      end
+    end
+  end
+end

data/lib/relaton/gost/docidentifier.rb

@@ -0,0 +1,80 @@
+module Relaton
+  module Gost
+    # Structured GOST document identifier. Wraps a Pubid::Gost identifier so the
+    # canonical citation form (e.g. "GOST R 34.12-2015", "GOST 14946-82") stays
+    # in sync with `content`, and undated-reference handling (return the latest
+    # edition) can strip the year via the pubid. Mirrors Relaton::Oiml::Docidentifier.
+    class Docidentifier < Bib::Docidentifier
+      attr_reader :pubid
+
+      # Capture the inherited content setter before overriding #content=, so
+      # #refresh_content! can write the re-rendered string back WITHOUT
+      # re-parsing. `remove_date!` used to re-sync through `self.content=`,
+      # which rebuilds @pubid from the string; harmless on its own, but a
+      # re-parse of an all-parts wrapper's own rendering (which carries
+      # pubid's "(all parts)" marker) would not round-trip at all.
+      alias_method :store_content, :content=
+
+      def initialize(attrs = {}, options = {})
+        pubid = attrs.is_a?(Hash) ? attrs.delete(:pubid) : nil
+        attrs[:content] ||= pubid.to_s if pubid
+        super
+        @pubid = pubid if pubid
+      end
+
+      def content=(value)
+        super
+        @pubid = ::Pubid::Gost.parse(value) if value
+      rescue StandardError
+        @pubid = nil
+      end
+
+      # `remove_date!` was implemented but `remove_part!` and `to_all_parts!`
+      # were not, so `Bib::ItemData#to_all_parts` still raised
+      # `NotImplementedError` on every GOST item — and it descends from
+      # `ScriptError`, so a caller's `rescue => e` did not catch it.
+      #
+      # GOST pubid carries the edition as `year` (not `date`), so `remove_date!`
+      # clears that: `GOST R 34.12-2015` -> `GOST R 34.12`. `part`/`subpart`
+      # come from the pubid base class and are unused by GOST today, so
+      # `remove_part!` is a no-op for the rendered string — implemented so it
+      # never raises. All three no-op safely when `@pubid` is nil.
+
+      def remove_part!
+        clear_attr!(:part)
+      end
+
+      def remove_date!
+        clear_attr!(:year)
+      end
+
+      def to_all_parts!
+        return if !@pubid || @pubid.all_parts?
+
+        # `remove_part!`/`remove_date!` mutate `@pubid` in place via direct
+        # attribute setters, so a bare reference (or a shallow `.dup`) would
+        # still see those mutations. `#exclude` with no args rebuilds the
+        # whole identifier as new objects — a real, independent snapshot —
+        # so the all-parts wrapper below keeps the original part and date.
+        original = @pubid.exclude
+        remove_part!
+        remove_date!
+        @pubid = original.to_all_parts
+      end
+
+      private
+
+      def clear_attr!(attr)
+        return unless @pubid && @pubid.respond_to?("#{attr}=")
+
+        @pubid.public_send("#{attr}=", nil)
+        @pubid.subpart = nil if attr == :part && @pubid.respond_to?(:subpart=)
+        refresh_content!
+      end
+
+      def refresh_content!
+        store_content(@pubid.to_s) if @pubid
+      end
+    end
+  end
+end

data/lib/relaton/gost/doctype.rb

@@ -0,0 +1,16 @@
+module Relaton
+  module Gost
+    # GOST document types. The value is carried in the inherited
+    # `content` attribute. The list mirrors the categories GOST
+    # publishes (interstate GOST, Russian national GOST R,
+    # preliminary standards, methodological documents).
+    class Doctype < Bib::Doctype
+      TYPES = %w[
+        interstate
+        national
+        preliminary
+        methodological
+      ].freeze
+    end
+  end
+end

data/lib/relaton/gost/ext.rb

@@ -0,0 +1,46 @@
+module Relaton
+  module Gost
+    # GOST bibliographic item extension. Adds GOST-specific structured
+    # metadata on top of the shared Relaton::Bib::Ext so the fields
+    # round-trip through both XML and YAML without per-repo merge hacks.
+    # Doctype is referenced lazily via autoload from lib/relaton/gost.rb.
+    class Ext < Bib::Ext
+      attribute :doctype,  Doctype
+      attribute :urn,      :string
+      attribute :webpage,  :string
+      # ICS classification code (МКС / Межгосударственный классификатор
+      # стандартов) — e.g. "13.080.20".
+      attribute :ics_code, :string
+      # Original-language developer of the standard (РАЗРАБОТЧИК).
+      attribute :developer, :string
+      # Keyword list (Ключевые слова).
+      attribute :keywords, :string, collection: true, initialize_empty: true
+      # Page count (Страниц).
+      attribute :pages,   :string
+      # Original-language designation as printed on the cover
+      # (e.g. "ГОСТ Р 71039— 2023") — preserves em-dash and spacing
+      # quirks that the parsed Pubid normalises away.
+      attribute :designation_original, :string
+
+      xml do
+        map_element "urn",                  to: :urn
+        map_element "webpage",              to: :webpage
+        map_element "ics_code",             to: :ics_code
+        map_element "developer",            to: :developer
+        map_element "keywords",             to: :keywords
+        map_element "pages",                to: :pages
+        map_element "designation_original", to: :designation_original
+      end
+
+      key_value do
+        map_element "urn",                  to: :urn
+        map_element "webpage",              to: :webpage
+        map_element "ics_code",             to: :ics_code
+        map_element "developer",            to: :developer
+        map_element "keywords",             to: :keywords
+        map_element "pages",                to: :pages
+        map_element "designation_original", to: :designation_original
+      end
+    end
+  end
+end