pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/itu/urn_generator.rb

@@ -23,19 +23,37 @@ module Pubid
           parts << "itu"
         end
 
+        # An ITU-R Report numbers independently of the Recommendation series,
+        # so "BT.2020-1" alone is ambiguous — the type has to reach the URN as
+        # well as `to_s` and the MR slug, or the two documents share an
+        # identifier on that surface.
+        parts << "report" if identifier.is_a?(Identifiers::Report)
+
         if identifier.series
           series = identifier.series.to_s
           if identifier.code
-            code = identifier.code.to_s
-            parts << "#{series}.#{code}"
+            # A series-code document joins with a dash, not a dot; rendering it
+            # "EMC.5" would be ambiguous with a hypothetical "ITU-T EMC.5" and
+            # would not parse back.
+            join = identifier.series_dash ? "-" : "."
+            parts << "#{series}#{join}#{identifier.code.compact_s}"
           else
             parts << series
           end
         elsif identifier.code
-          code = identifier.code.to_s
+          code = identifier.code.compact_s
           parts << code
         end
 
+        # Identity-bearing markers that are not part of sector/series/code.
+        # Without them "ITU-T H.350 attachment", "ITU-T Q.120-Q.139" and
+        # "ITU-T E-100 series Suppl. 2" would each share a URN with the
+        # document they are distinct from — the same collision Code#compact_s
+        # exists to prevent for the code suffixes.
+        parts << "series" if identifier.series_word
+        parts << "attachment" if identifier.attachment
+        parts << "to-#{identifier.range_end}" if identifier.range_end
+
         if identifier.date
           date = identifier.date
           if date&.year && date.month
@@ -57,8 +75,16 @@ module Pubid
 
         base = maybe(:base)
         if base
-          base_gen = self.class.new(base)
-          base_urn = base_gen.generate_base_urn
+          # An annex or appendix base holds its identity in its OWN base (its
+          # sector/series/code are nil), so generate_base_urn would emit
+          # "urn:itu:itu" for it — go through its own to_urn instead.
+          nested_wrapper = base.is_a?(Identifiers::AnnexOfRecommendation) ||
+            base.is_a?(Identifiers::AppendixOfRecommendation)
+          base_urn = if nested_wrapper
+                       base.to_urn
+                     else
+                       self.class.new(base).generate_base_urn
+                     end
 
           base_part = base_urn.sub(/^urn:itu:/, "")
           base_parts = base_part.split(":")
@@ -72,12 +98,16 @@ module Pubid
           if identifier.series
             series = identifier.series.to_s
             if identifier.code
-              code = identifier.code.to_s
+              code = identifier.code.compact_s
               parts << "#{series}.#{code}"
             else
               parts << series
             end
           end
+          # A base-less supplement's whole identity is sector + series, so the
+          # series-group word belongs in the URN too — without it
+          # "ITU-T E-100 series Suppl. 2" and "ITU-T E-100 Suppl. 2" collide.
+          parts << "series" if identifier.series_word
         end
 
         supplement_notation = maybe(:supplement_notation)

data/lib/pubid/itu/urn_parser.rb

@@ -16,6 +16,14 @@ module Pubid
         body = strip_namespace(urn)
         parts = split_parts(body)
         sector, code = parts
+
+        # UrnGenerator emits a "report" segment between the sector and the code
+        # for an ITU-R Report, which numbers independently of the
+        # Recommendation series (urn:itu:r:report:BT.2020-1).
+        if parts[1] == "report"
+          return flavor_parse("Report ITU-#{sector.upcase} #{parts[2]}")
+        end
+
         flavor_parse("ITU-#{sector.upcase} #{code}")
       end
     end

data/lib/pubid/itu.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 require "lutaml/model"
 
 module Pubid
@@ -7,11 +8,19 @@ module Pubid
     extend Pubid::PrefixesSupport
 
     # Sole ITU publisher token (see the parser's `itu_prefix` rule).
+    #
+    # The leading "Report" of an ITU-R Report's canonical form
+    # ("Report ITU-R BT.2020-1") is deliberately NOT listed: prefix routing
+    # claims every reference beginning with the token, and "Report" is a
+    # generic English word that other SDOs' references start with — the
+    # mixin's documented exclusion for ambiguous tokens. Report references
+    # route by their "ITU" token in the infix spelling
+    # ("ITU-R Report BT.2020-1"), and `Pubid::Itu.parse` accepts both.
     PREFIXES = ["ITU"].freeze
 
     autoload :Builder, "#{__dir__}/itu/builder"
     autoload :Components, "#{__dir__}/itu/components"
-    autoload :Identifier, "#{__dir__}/itu/identifier"
+    autoload :Identifier, "#{__dir__}/itu/identifiers/base"
     autoload :Identifiers, "#{__dir__}/itu/identifiers"
     autoload :Parser, "#{__dir__}/itu/parser"
     autoload :UrnGenerator, "#{__dir__}/itu/urn_generator"
@@ -32,9 +41,9 @@ module Pubid
       @identifier_types ||= Identifiers.constants
         .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
         .select { |c| c.is_a?(Class) && c < Pubid::Identifier }
-        # Exclude the flavor base itself by identity (Identifiers::Base is now an
+        # Exclude the flavor base itself by identity (Identifier is now an
         # alias for Pubid::Itu::Identifier, so name-based matching misses it).
-        .reject { |c| c == Identifiers::Base }
+        .reject { |c| c == Identifier }
     end
 
     # Build typed stage index from identifier types

data/lib/pubid/jcgm/builder.rb

@@ -4,8 +4,11 @@ module Pubid
   module Jcgm
     class Builder < Pubid::Builder::Base
       def locate_identifier_klass(parsed_hash)
-        if parsed_hash[:base_identifier]
-          return Jcgm.locate_type(:amendment)
+        if parsed_hash[:base]
+          type_with_stage = parsed_hash[:type_with_stage]
+          return Jcgm.locate_type(:amendment) unless type_with_stage
+
+          return Jcgm.locate_type(locate_typed_stage(type_with_stage).type_code)
         end
 
         if parsed_hash[:gum_number]
@@ -22,15 +25,26 @@ module Pubid
       end
 
       def build(parsed_hash)
-        identifier = locate_identifier_klass(parsed_hash).new
+        klass = locate_identifier_klass(parsed_hash)
+
+        # GUM guides store their part number in the shared `number` attribute
+        # ("JCGM GUM-6" -> number "6"); the parser tags it :gum_number only to
+        # pick this class. Fold it back onto :number before assigning.
+        if parsed_hash[:gum_number] && klass == Identifiers::GumGuide
+          parsed_hash = parsed_hash.merge(number: parsed_hash[:gum_number])
+          parsed_hash.delete(:gum_number)
+        end
+
+        identifier = klass.new
         assign_attributes(identifier, parsed_hash)
 
+        # Bare guides/gum-guides carry no parsed stage; derive the (single,
+        # published) typed_stage from the concrete class so parse and from_hash
+        # agree. Avoids the ambiguous locate_stage("") lookup (Guide and
+        # GumGuide both register abbr: [""]).
         if identifier.class.attributes.key?(:typed_stage) && identifier.typed_stage.nil?
-          default_typed_stage = Jcgm.locate_stage("") ||
-            raise(ArgumentError, "Unknown type abbreviation: ''")
-          identifier.typed_stage = default_typed_stage
-          identifier.stage = default_typed_stage.to_stage if identifier.class.attributes.key?(:stage)
-          identifier.type = default_typed_stage.to_type if identifier.class.attributes.key?(:type)
+          identifier.typed_stage = identifier.class.published_typed_stage ||
+            raise(ArgumentError, "No published typed_stage for #{identifier.class}")
         end
 
         identifier
@@ -50,14 +64,12 @@ module Pubid
 
       def cast(type, value)
         case type
-        when :base_identifier
+        when :base
           build(value)
         when :publisher
           Jcgm::Components::Publisher.new(publisher: value.to_s)
         when :number
-          Pubid::Components::Code.new(value: value.to_s)
-        when :gum_number
-          Pubid::Components::Code.new(value: value.to_s)
+          value.to_s
         when :date
           date_str = value.to_s
           if date_str.include?("-")
@@ -70,8 +82,6 @@ module Pubid
           else
             Pubid::Components::Date.new(year: date_str)
           end
-        when :iteration
-          Pubid::Components::Code.new(value: value.to_s)
         when :type_with_stage
           typed_stage = locate_typed_stage(value.to_s)
           {

data/lib/pubid/jcgm/identifier.rb

@@ -3,6 +3,16 @@
 module Pubid
   module Jcgm
     class Identifier < ::Pubid::Identifier
+      # `number`/`part`/`subpart` are declared here rather than inherited as a
+      # Components::Code: JCGM stores a bare string in `number` and uses neither
+      # of the other two. Declaring on this class is safe because its body lives
+      # in this one file and is never reopened, so every subclass body opens
+      # after it has run (lutaml deep-dups the parent attribute table at
+      # class-definition time).
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
+
       def self.parse(string)
         Pubid::Jcgm.parse(string)
       end

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

@@ -4,8 +4,6 @@ module Pubid
   module Jcgm
     module Identifiers
       class Amendment < SupplementIdentifier
-        attribute :type, Pubid::Components::Type, default: -> { self.class.type[:key] }
-
         TYPED_STAGES = [
           Pubid::Components::TypedStage.new(
             code: :pubamd,

data/lib/pubid/jcgm/identifiers/corrigendum.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Identifiers
+      # A JCGM corrigendum. Two surface forms are supported:
+      #
+      #   "JCGM 200:2008 Corrigendum"      — base guide + trailing " Corrigendum"
+      #                                       word, no iteration number
+      #   "JCGM 101:2008/Cor 1:2009"       — base guide + slash-separated
+      #                                       numbered corrigendum with date
+      #
+      # The first form is the JCGM-native convention. The second mirrors the
+      # ISO/IEC supplement syntax and is needed to round-trip identifiers like
+      # "JCGM 101:2008/Cor 1:2009" (corrigendum to GUM Supplement 1).
+      class Corrigendum < SupplementIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubcorr,
+            stage_code: :published,
+            type_code: :corrigendum,
+            abbr: %w[Corrigendum Cor],
+            name: "Corrigendum",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :corrigendum, title: "Corrigendum", short: "Corr" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/identifiers/gum_guide.rb

@@ -3,10 +3,10 @@
 module Pubid
   module Jcgm
     module Identifiers
+      # A GUM guide, e.g. "JCGM GUM-6:2020". The GUM-series part number ("6")
+      # lives in the inherited `number` attribute (serialized as `number: "6"`);
+      # `_type: pubid:jcgm:gum-guide` disambiguates it from a plain guide.
       class GumGuide < SingleIdentifier
-        attribute :gum_number, Pubid::Components::Code
-        attribute :type, Pubid::Components::Type, default: -> { self.class.type[:key] }
-
         TYPED_STAGES = [
           Pubid::Components::TypedStage.new(
             code: :pubgumguide,

data/lib/pubid/jcgm/identifiers/meeting.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Identifiers
+      # A JCGM committee/meeting record, e.g. "JCGM 17th Meeting (2012)".
+      #
+      # `number` (Components::Code) holds the meeting ordinal as a clean integer
+      # value ("17"); `date` (Components::Date, year-only) holds the year.
+      class Meeting < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubmeeting,
+            stage_code: :published,
+            type_code: :jcgm_meeting,
+            abbr: ["Meeting"],
+            name: "Meeting",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :jcgm_meeting, title: "Meeting" }
+        end
+
+        # Ordinal suffix as printed by the JCGM/BIPM data generator: a naive
+        # last-digit rule (1->st, 2->nd, 3->rd, else th) with NO 11/12/13 teens
+        # exception. The real records print "11st", "12nd", "13rd", so applying
+        # the standard-English teens exception would break round-trip.
+        def self.ordinal(number)
+          n = number.to_i
+          suffix = case n % 10
+                   when 1 then "st"
+                   when 2 then "nd"
+                   when 3 then "rd"
+                   else "th"
+                   end
+          "#{n}#{suffix}"
+        end
+
+        def ordinal
+          self.class.ordinal(number)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/identifiers.rb

@@ -4,8 +4,10 @@ module Pubid
   module Jcgm
     module Identifiers
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :Guide, "#{__dir__}/identifiers/guide"
       autoload :GumGuide, "#{__dir__}/identifiers/gum_guide"
+      autoload :Meeting, "#{__dir__}/identifiers/meeting"
     end
   end
 end

data/lib/pubid/jcgm/parser.rb

@@ -4,24 +4,86 @@ require "parslet"
 
 module Pubid
   module Jcgm
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 
       root :identifier
 
       rule(:identifier) do
-        amendment_identifier | base_identifier
+        meeting_identifier | amendment_identifier | corrigendum_identifier |
+          numbered_corrigendum_identifier | base | named_guide_identifier
       end
 
-      rule(:base_identifier) do
-        publisher >> space >> number_portion >> date_portion >> language_portion.maybe
+      # "JCGM 200:2008 Corrigendum" — a base guide plus a trailing
+      # " Corrigendum" word (no number). Must precede base: Parslet
+      # is an ordered PEG that commits to the first matching alternative, so if
+      # base ran first it would consume "JCGM 200:2008" and root
+      # would fail on the leftover " Corrigendum". Emits type_with_stage so the
+      # builder routes it to Corrigendum.
+      rule(:corrigendum_identifier) do
+        base.as(:base) >> space >>
+          str("Corrigendum").as(:type_with_stage)
+      end
+
+      # "JCGM 101:2008/Cor 1:2009" — a base guide plus a slash-separated
+      # numbered corrigendum (mirrors the ISO/IEC supplement form). The
+      # trailing :YYYY is optional so "JCGM 101:2008/Cor 1" also parses.
+      # Must precede base for the same PEG-commit reason as corrigendum_identifier.
+      rule(:numbered_corrigendum_identifier) do
+        base.as(:base) >>
+          str("/") >> str("Cor").as(:type_with_stage) >>
+          space >> digits.as(:number) >>
+          corrigendum_date.maybe
+      end
+
+      # Dateless "named" guides: "JCGM GUM", "JCGM VIM-3" (and future "VIM-N").
+      # Last in the alternation — only reached when base fully fails
+      # (these have no date, so number_portion/date_portion never match).
+      rule(:named_guide_identifier) do
+        publisher >> space >> named_number
+      end
+
+      rule(:named_number) do
+        (str("GUM") | (str("VIM") >> (str("-") >> digits).maybe)).as(:number)
+      end
+
+      # Committee/meeting record, e.g. "JCGM 17th Meeting (2012)". Diverges
+      # from base right after the digits (base wants ":", meeting
+      # wants the ordinal suffix), so ordered choice is unambiguous. Emits the
+      # same tokens as a guide plus type_with_stage "Meeting", so the generic
+      # builder path resolves it to Identifiers::Meeting (like "Amd").
+      #
+      # The trailing " (YYYY)" group is optional, so the partial reference
+      # "JCGM 11st Meeting" parses with `date` left nil. JCGM numbers its
+      # meetings in one sequence, so the ordinal alone names the event and the
+      # year is redundant detail. The whole group is `.maybe` (not the year
+      # inside it), so a dangling "(" or a truncated year still fails —
+      # the same shape as `date_portion.maybe` in `rule(:base)`.
+      rule(:meeting_identifier) do
+        publisher >> space >> digits.as(:number) >> ordinal_suffix >>
+          space >> str("Meeting").as(:type_with_stage) >>
+          (space >> str("(") >> year_digits.as(:date) >> str(")")).maybe
+      end
+
+      rule(:ordinal_suffix) do
+        str("st") | str("nd") | str("rd") | str("th")
+      end
+
+      # `date_portion` is optional so a partial reference that omits the
+      # trailing `:YYYY` date (e.g. "JCGM 100") parses with `date` left nil,
+      # letting relaton match a collection via `matches?(row, ignore: [:date])`.
+      # The whole sub-rule is `.maybe` (not the year inside it) so a dangling
+      # ":" still fails. Mirrors ETSI (lib/pubid/etsi/parser.rb).
+      rule(:base) do
+        publisher >> space >> number_portion >>
+          date_portion.maybe >> language_portion.maybe
       end
 
       rule(:amendment_identifier) do
-        base_identifier.as(:base_identifier) >>
+        base.as(:base) >>
           str("/") >> amendment_type >>
-          space >> amendment_number >>
+          space >> digits.as(:number) >>
           amendment_date.maybe
       end
 
@@ -73,12 +135,17 @@ module Pubid
       end
 
       rule(:amendment_number) do
-        digits.as(:iteration)
+        digits.as(:number)
       end
 
       rule(:amendment_date) do
         str(":") >> (full_date | year_only)
       end
+
+      # Numbered corrigendum date: same shape as amendment_date.
+      rule(:corrigendum_date) do
+        str(":") >> (full_date | year_only)
+      end
     end
   end
 end

data/lib/pubid/jcgm/renderer.rb

@@ -13,20 +13,41 @@ module Pubid
     # registry and invoked via `render(format: :human)`.
     class Renderer < ::Pubid::Renderers::Base
       def render(context: nil, **opts)
-        id = @id
-
-        case id
-        when Identifiers::Amendment
-          render_amendment(id, context)
-        when Identifiers::GumGuide
-          render_gum_guide(id, context)
-        else
-          render_single(id)
+        case @id
+        when Identifiers::Amendment then render_amendment(@id, context)
+        when Identifiers::Corrigendum then render_corrigendum(@id)
+        when Identifiers::GumGuide then render_gum_guide(@id, context)
+        when Identifiers::Meeting then render_meeting(@id)
+        else render_single(@id)
         end
       end
 
       private
 
+      def render_corrigendum(id)
+        # Two surface forms:
+        #   "JCGM 200:2008 Corrigendum"  — number absent (word form)
+        #   "JCGM 101:2008/Cor 1:2009"   — number present (numbered form)
+        return "#{id.base}/Cor #{id.number}#{corrigendum_date_suffix(id)}" if id.number
+
+        "#{id.base} Corrigendum"
+      end
+
+      def corrigendum_date_suffix(id)
+        id.date ? ":#{id.date}" : ""
+      end
+
+      # Two surface forms:
+      #   "JCGM 17th Meeting (2012)"  — date present (published records)
+      #   "JCGM 17th Meeting"         — date absent (partial reference)
+      # The ordinal alone names the meeting, so the dateless form is a valid
+      # identifier and must stay re-parseable (the parser makes the " (YYYY)"
+      # group optional to match).
+      def render_meeting(id)
+        base = "JCGM #{id.ordinal} Meeting"
+        id.date ? "#{base} (#{id.date.year})" : base
+      end
+
       def render_single(id)
         parts = [id.publisher_portion]
         parts << id.number_portion unless id.number_portion.empty?
@@ -36,9 +57,9 @@ module Pubid
       end
 
       def render_amendment(id, context)
-        result = id.base_identifier.to_s if id.base_identifier
+        result = id.base.to_s if id.base
         result += "/Amd"
-        result += " #{id.iteration.render(context:)}" if id.iteration
+        result += " #{id.number}" if id.number
         result += ":#{id.date}" if id.date
         result
       end
@@ -46,7 +67,7 @@ module Pubid
       def render_gum_guide(id, context)
         parts = []
         parts << id.publisher.publisher if id.publisher
-        parts << "GUM-#{id.gum_number.render(context:)}" if id.gum_number
+        parts << "GUM-#{id.number}" if id.number
 
         result = parts.join(" ")
         result += ":#{id.date}" if id.date

data/lib/pubid/jcgm/single_identifier.rb

@@ -3,17 +3,95 @@
 module Pubid
   module Jcgm
     class SingleIdentifier < Identifier
-      attribute :publisher, Jcgm::Components::Publisher
-      attribute :typed_stage, Pubid::Components::TypedStage
-      attribute :number, Pubid::Components::Code
+      attribute :publisher, Jcgm::Components::Publisher,
+                default: -> { self.class.default_publisher }
+      attribute :typed_stage, Pubid::Components::TypedStage,
+                default: -> { self.class.published_typed_stage }
       attribute :date, Pubid::Components::Date
       attribute :languages, Pubid::Components::Language, collection: true
       attribute :stage, Pubid::Components::Stage
       attribute :type, Pubid::Components::Type
 
-      # Generate URN for this identifier
+      # Compact serialization: only per-instance information is mapped. The
+      # publisher (always "JCGM") and the derived type / stage / typed_stage
+      # (fully determined by the class, i.e. `_type`) are intentionally NOT
+      # mapped — they are reconstructed from the class on load via the
+      # attribute defaults above. Components collapse to bare scalars:
+      # number is already a bare :string; date -> year/month/day scalars.
+      # Mirrors ISO (lib/pubid/iso/identifier.rb) and OIML.
+      key_value do
+        map "_type", to: :_type
+        map "number", with: { to: :number_to_kv, from: :number_from_kv }
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "month", with: { to: :month_to_kv, from: :month_from_kv }
+        map "day", with: { to: :day_to_kv, from: :day_from_kv }
+        map "languages", to: :languages
+      end
+
+      # The publisher implied when none is serialized — always JCGM.
+      def self.default_publisher
+        Jcgm::Components::Publisher.new(publisher: Jcgm::PREFIXES.first)
+      end
+
+      # The class's published typed_stage (canonical surface form). Each JCGM
+      # class registers exactly one, all :published; `_type` fixes the class,
+      # so an omitted typed_stage reconstructs deterministically on from_hash.
       #
-      # @return [String] URN representation
+      # `original_abbr` is deliberately LEFT NIL. It records the spelling the
+      # input used and is not serialized, so it cannot survive a round trip —
+      # and this method is one of the two paths that fill `typed_stage`. The
+      # other is the parse path (`Builder#locate_typed_stage` ->
+      # `Jcgm.locate_stage`), which returns the registry entry untouched.
+      # Setting it here made the two disagree, so `from_hash(to_hash) != parse`
+      # for every type the grammar tags (Meeting, Corrigendum, Amendment) —
+      # and because `#matches?` is `exclude(...) == other.exclude(...)`, a
+      # relaton index lookup then silently matched nothing. Nothing in JCGM
+      # reads the field: the renderer hardcodes its surface words, the URN
+      # generator reads only `type_code`, and `TypedStage#abbreviation` chooses
+      # among long_abbr/short_abbr/abbr.first. Recording the *matched* token
+      # instead would not work either — "/Cor 1" would store "Cor" where
+      # from_hash rebuilds "Corrigendum".
+      def self.published_typed_stage
+        return nil unless const_defined?(:TYPED_STAGES)
+
+        ts = self::TYPED_STAGES.find { |t| t.stage_code.to_s == "published" }
+        # dup: locate_stage hands out the shared object from the frozen
+        # TYPED_STAGES array (the array is frozen, its elements are not), so a
+        # future in-place mutation would otherwise leak globally.
+        ts&.dup
+      end
+
+      # type and stage are derived from typed_stage, never stored — so the
+      # doctype (fixed by the class / _type) is not carried in the hash.
+      def type
+        typed_stage&.to_type
+      end
+
+      def stage
+        typed_stage&.to_stage
+      end
+
+      # --- number ---
+      def number_to_kv(model, doc) = emit_kv(doc, "number", model.number)
+      def number_from_kv(model, value) = model.number = value.to_s
+
+      # --- date flattened to top-level year/month/day scalars ---
+      def year_to_kv(model, doc) = emit_kv(doc, "year", model.date&.year)
+      def month_to_kv(model, doc) = emit_kv(doc, "month", model.date&.month)
+      def day_to_kv(model, doc) = emit_kv(doc, "day", model.date&.day)
+      def year_from_kv(model, value) = date_for(model).year = value.to_s
+      def month_from_kv(model, value) = date_for(model).month = value.to_s
+      def day_from_kv(model, value) = date_for(model).day = value.to_s
+
+      def emit_kv(doc, key, value)
+        return if value.nil? || value.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, value.to_s))
+      end
+
+      def date_for(model)
+        model.date ||= Pubid::Components::Date.new
+      end
 
       def publisher_portion
         publisher.to_s
@@ -21,7 +99,7 @@ module Pubid
 
       def number_portion
         parts = []
-        parts << number.value if number
+        parts << number if number
         parts << ":#{date.year}" if date
         parts.join
       end