pubid 2.0.0.pre.alpha.11 → 2.0.0.pre.alpha.13

data/lib/pubid/ieee/renderer.rb

@@ -115,26 +115,33 @@ module Pubid
         parts << id.draft_status if id.draft_status
 
         # Type - only render for IEEE/AIEE publishers, and only for non-projects.
-        # An unapproved draft is not yet a standard, so per IEEE guidance the
-        # "Std" token is dropped from the type when draft_status is "Unapproved"
-        # (e.g. "Draft Std" -> "Draft", "Std" -> "").
+        # A status word ("Unapproved") already marks the document as a draft,
+        # so the WHOLE type word is dropped — not just "Std" (pubid#318: the
+        # half-strip left "Draft" in the render, the re-parse dropped it, and
+        # to_s needed three rounds to converge while losing the type).
         should_render_type = id.publisher&.match?(/^(IEEE|AIEE)/)
 
-        if should_render_type && !id.typed_stage&.project_status && id.type && !id.type.to_s.strip.empty? && id.type != "P"
+        if should_render_type && !id.typed_stage&.project_status && id.type && !id.type.to_s.strip.empty? && id.type != "P" &&
+            !id.draft_status.to_s.match?(/unapproved/i)
           type_str = id.type.dup
           type_str = type_str.sub(/^P/, "") if type_str.start_with?("P")
-          if id.draft_status.to_s.match?(/unapproved/i)
-            type_str = type_str.gsub(/\bStd\b/i, "").squeeze(" ").strip
-          end
           parts << type_str unless type_str.strip.empty?
         end
 
-        # Code - with P prefix for projects (concatenated, not separated)
+        # Code - with P prefix for projects (concatenated, not separated).
+        # IEEE semantics (normative): P = project = the document is a
+        # draft; no P = it has become a standard. The P-state is
+        # identity-bearing, so the renderer never adds or drops it —
+        # whatever the source spelling carries round-trips.
         if id.code_obj
           result = id.code_obj.to_s
 
-          # Prepend P if this is a project AND code doesn't already have P
-          if id.typed_stage&.project_status && should_render_type && !result.start_with?("P")
+          # Prepend P if this is a project AND code doesn't already have P.
+          # A recorded project marker (the source spelled the P on a
+          # non-IEEE-led publisher) prints regardless of the publisher.
+          if (id.typed_stage&.project_status && should_render_type ||
+              id.is_a?(Identifiers::ProjectDraftIdentifier) &&
+              id.project_marker) && !result.start_with?("P")
             result = "P#{result}"
           end
 
@@ -143,6 +150,7 @@ module Pubid
           result += mark(id.code_obj.number, id.code_obj.prefix,
                          publishers: publishers_of(id))
 
+
           # Only attach year to code if there's no edition, no month, and no draft
           result += "-#{id.year}" if id.year && !id.draft_obj && !id.edition && !id.month
 
@@ -151,9 +159,29 @@ module Pubid
           # ("P802.16Rev2/D3"). Keeps a revision distinct from its base standard.
           result += "Rev#{id.revision}" if id.revision
 
-          # Append draft to code - with or without space based on original format
+          # Append draft to code - with or without space based on original
+          # format. An exactly-IEC/IEEE co-published reference prints only the
+          # draft DESIGNATOR - a comma-separated project date ("IEC/IEEE
+          # 61886-1/D2, May 2020" prints as "…/D2") is catalogue metadata, not
+          # identity. Wider sets ("IEC/ISO/IEEE P82079-1/D1, June 2016") print
+          # the date; a space-separated date always stays ("…/DCDV July 2015").
+          # IEEE-published drafts normalize the comma date to the long form
+          # ("D08, September, 2018").
           if id.draft_obj
-            result += id.space_before_draft ? " #{id.draft_obj}" : id.draft_obj.to_s
+            printed = id.draft_obj.to_s
+            if id.publisher == "IEC" && id.copublisher == ["IEEE"]
+              printed = printed.split(", ").first
+            elsif id.publisher == "IEEE" && id.draft_status.to_s.empty?
+              # The long comma form is for dated project drafts; an
+              # unapproved-draft render keeps its pinned single-comma form
+              # (pubid#318 idempotence).
+              printed = printed.sub(/, ([A-Z][a-z]+) (\d{4})\z/, ', \1, \2')
+            end
+            # A space-separated draft year with no print date trailing is
+            # IEEE's dash form ("…/D1-2006"); with a trailing print date the
+            # space stays ("…/D1 2004, Nov 2004").
+            printed = printed.sub(/\A(D\d+) (\d{4})\z/, '\1-\2')
+            result += id.space_before_draft ? " #{printed}" : printed
           end
 
           # Append interpretation notation (/INT)
@@ -191,8 +219,12 @@ module Pubid
         # Build the main identifier (without month yet)
         result = parts.join(" ")
 
-        # Month/Day - append directly to avoid extra space before comma
-        if id.month
+
+        # Month/Day - append directly to avoid extra space before comma.
+        # An exactly-IEC/IEEE co-published reference drops the comma date
+        # entirely (same catalogue-metadata rule as the draft date above):
+        # "IEC/IEEE P60076-16, May 2016" prints as "IEC/IEEE 60076-16".
+        if id.month && !(id.publisher == "IEC" && id.copublisher == ["IEEE"])
           result += ", #{id.month}"
           result += " #{id.day}" if id.day
           if id.year && !id.edition

data/lib/pubid/ieee/urn_generator.rb

@@ -127,6 +127,10 @@ module Pubid
       end
 
       def publisher_component
+        # The IEC/IEEE co-published pair is definitional to the class and
+        # was previously lost ("urn:ieee:ieee" — no number, no draft).
+        return "iec-ieee" if identifier.is_a?(Identifiers::IecIeeeCopublished)
+
         pub = normalized_publisher
 
         if identifier.copublisher&.any?
@@ -150,6 +154,14 @@ module Pubid
       end
 
       def type_component
+        # A joint stage draft carries the stage in its draft clause and the
+        # project P inside the code — a separate type segment would
+        # duplicate both.
+        if identifier.is_a?(Identifiers::JointDevelopment) &&
+           identifier.ieee_draft.to_s.start_with?("D=")
+          return nil
+        end
+
         return nil unless identifier.type
 
         type = identifier.type
@@ -159,6 +171,16 @@ module Pubid
       end
 
       def code_component
+        # The co-published code is number+parts+separators (no year — its
+        # own segment), e.g. "61886-1".
+        if identifier.is_a?(Identifiers::IecIeeeCopublished)
+          return nil if identifier.number.to_s.empty?
+
+          # Year-less: the publication year is its own URN segment (the
+          # rebuilt copublished_number would double-emit it).
+          return "#{identifier.number}#{identifier.parts_suffix}"
+        end
+
         return nil unless identifier.code_obj
 
         identifier.code_obj.to_s
@@ -182,6 +204,15 @@ module Pubid
       end
 
       def draft_component
+        if identifier.is_a?(Identifiers::JointDevelopment) &&
+           identifier.ieee_draft.to_s.start_with?("D=")
+          return "draft.#{identifier.ieee_draft}"
+        end
+
+        if identifier.is_a?(Identifiers::IecIeeeCopublished)
+          return identifier.draft_info ? "draft.#{identifier.draft_info}" : nil
+        end
+
         return nil unless identifier.draft_obj
 
         "draft.#{identifier.draft_obj}"

data/lib/pubid/ieee.rb

@@ -20,6 +20,7 @@ module Pubid
     autoload :Parser, "#{__dir__}/ieee/parser"
     autoload :PreParser, "#{__dir__}/ieee/pre_parser"
     autoload :Compaction, "#{__dir__}/ieee/compaction"
+    autoload :ProjectRenderer, "#{__dir__}/ieee/project_renderer"
     autoload :Renderer, "#{__dir__}/ieee/renderer"
     autoload :TypedStages, "#{__dir__}/ieee/typed_stages"
     autoload :UrnGenerator, "#{__dir__}/ieee/urn_generator"
@@ -162,3 +163,4 @@ Pubid::Registry.register(:ieee, Pubid::Ieee)
 # Per-flavor format registry: inherits global formats, overrides :human
 Pubid::Ieee::Identifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
 Pubid::Ieee::Identifier.format_registry.register(:human, renderer: Pubid::Ieee::Renderer)
+Pubid::Ieee::Identifier.format_registry.register(:project, renderer: Pubid::Ieee::ProjectRenderer)

data/lib/pubid/ietf/CLAUDE.md

@@ -0,0 +1,7 @@
+# IETF flavor notes
+
+IETF readiness for the unified relaton index.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/ietf/` or `spec/pubid/ietf/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **IETF readiness for the unified relaton index (`relaton-data-ietf`)**: relaton is collapsing RFCs, the RFC sub-series (BCP/STD/FYI) and Internet-Drafts into **one** index keyed on the structured pubid hash (`pubid_class: ::Pubid::Ietf::Identifier`). That index is **all-or-nothing** — `Relaton::Index::FileIO#deserialize_id` raises on the *first* unparseable row and `#load_index` then rejects the whole index — so one bad id out of 176,862 means no consumer resolves *any* IETF reference. Four changes, all verified against the published corpora (`relaton-data-{rfcs,rfcsubseries,ids}`, branch `v2`). **(1) `draft_rest` accepts `.` and `A-Z`** (`match['a-zA-Z0-9+_.\-']`): exactly 50 of the 166,740 published draft ids failed without them (21 dotted `draft-ietf-pilc-2.5g3g-12`, 29 uppercase `draft-chapin-clnp-ISO8473-00`, 0 both), and a character census confirms the class now covers the corpus **exactly** — the only chars outside `[a-z0-9-]` anywhere in it are `. _ +` and `A-Z`. Widening is safe because the top-level alternation is keyed on the leading token (`RFC`/`BCP|STD|FYI`/`draft-`), so a wider draft tail can never make another branch match; `Builder#split_draft_version` needed no change (it inspects only the last three characters). The set stays **closed** — a space, `/` or `&` in a slug is crawler junk and still fails (pinned by negative examples). **(2) Zero-padded ids parse, grammar-level**: `rfc-index.xml` writes sub-series membership as `<is-also><doc-id>STD0066</doc-id></is-also>` (369 padded doc-ids) and RFCs as `RFC0001`, and relaton#109 forbids relaton normalizing them itself. The space is `.maybe` on both the `rfc` and `subseries` rules and `Builder#unpad` strips the pad (`/\A0+(?=\d)/`, a look-ahead so an all-zero number keeps its last digit), so `STD0066`/`STD 0066`/`STD66` all render the canonical `STD 66`. `unpad` is applied unconditionally, so the **spaced** padded form is normalized too — `RFC 0001` previously parsed and rendered back verbatim, and now renders `RFC 1` with a correspondingly changed hash and URN. That is deliberate (one canonical spelling per document) and has **zero** effect on the published corpora, which contain no padded row. **This is a normalizing parse, so the padded spellings must NEVER go into the byte-exact `spec/fixtures/ietf/identifiers/pass/`** — they live in `spec/pubid/ietf/zero_padded_spec.rb`, the BIPM `CIPM/2005-06(REV)` precedent. **(3) The Internet-Draft slug moved from `name` into `number`, and `series` became derived**: relaton bsearches on `id.root.number.to_s`, so with the slug in `name` all 166,740 drafts keyed to `""` and the narrowing bought nothing (with the slug: 43,564 buckets, median 2, worst 101). `name` is **dropped entirely** (no alias); the slug — leading `draft-` included — is the key, deliberately shared by a draft's unversioned aggregator row and every one of its versions so a document and its variants cluster. `series` is likewise **not stored**: `_type: pubid:ietf:std` already encodes it, so `Bcp`/`Std`/`Fyi` expose a `SERIES` constant + a plain `#series` reader (safe — `::Pubid::Identifier` declares no `series` attribute and nothing generic reads `.series`) and `build_subseries` stops passing it. The whole serialized vocabulary is now **three keys**: `_type` + `number` always, `version` only on a versioned draft — a sub-series row (`{_type, number}`) has the same shape as an RFC's. **The attributes live on the five LEAVES, not the shared `Pubid::Ietf::Identifier`**, via the `Identifiers::Serialization` mixin (`number` + the `key_value` block; `InternetDraft` merges its own `version` mapping on top — lutaml combines a mixin-installed block with a second in-class one, the ITU precedent). This is the IEEE `number` determinism landmine: a `:string` redefinition of the parent's `Components::Code number` on a class the leaves *inherit* from resolves nondeterministically under multi-flavor load. It was invisible while drafts left `number` nil; it is load-bearing now. The base deliberately carries **no** `key_value` block — one there would be inherited-and-merged by every leaf. `spec/pubid/ietf/root_number_spec.rb` is the tripwire (asserts `number` is a `String`, the exact keys, the exact `to_hash` key sets) and **must run under the full `rake` suite** to mean anything. **(4) Round-trip is validated here because relaton structurally cannot**: `FileIO#id_supported?` **skips** its `to_hash`/`from_hash` check whenever the object is a concrete subclass (`return true unless obj.instance_of?(@pubid_class)`), and *every* IETF id is a subclass — so a lossy round-trip would pass validation silently and produce wrong lookups. Three layers: `fixtures_spec.rb` is now **zero-failure** (was a 90% threshold — wrong for an all-or-nothing index) and checks `to_s` byte-exactness, `from_hash(to_hash)` fidelity in both `to_s` and `to_hash`, **and** a non-empty `root.number` for every fixture line; the fixtures grew to ~2,500 lines (the complete 365-row sub-series corpus, a 139-id structural edge set, a deterministic 1-in-84 draft sample — each file's header records the regeneration command); and `spec/pubid/ietf/corpus_round_trip_spec.rb` runs the same four checks over all 176,862 published ids, **opt-in** via `PUBID_IETF_CORPUS=<dir with the three relaton-data checkouts> bundle exec rake test:corpus_ietf` (self-skips otherwise; ~100s; verified 0 failures). **relaton note — the indexes must be regenerated, there is no alias**: `name` and `series` are gone as serialized keys, so a pre-`number` row (`{_type, name, version}`) deserializes with **`number` nil** and no error at all — lutaml ignores unknown keys, and relaton's subclass skip means `id_supported?` won't catch it either, leaving every draft keyed under `""`. Rendering is therefore the loud failure: `Renderer#require_number!` raises `ArgumentError` on a nil/empty `number` rather than returning `nil` or `"-02"`, and the renderer's sub-series arm is an explicit `when Bcp, Std, Fyi` with an `else raise` instead of a catch-all (a bare `Pubid::Ietf::Identifier` has no `series` reader). Pinned by the "legacy `name`-shaped hash" block in `root_number_spec.rb`. **Pre-existing bug fixed in passing**: `UrnParser`'s bare `Errors::ParseError` does not resolve — `Errors` lives under `Pubid::UrnParser` (the module), which is neither in the lexical scope of `Pubid::Ietf::UrnParser` nor an ancestor of `Base` — so an invalid URN raised `NameError` instead, and the spec's `raise_error(StandardError)` accepted it. Now fully qualified as `Pubid::UrnParser::Errors::ParseError` (the adobe/easc/gost/iala convention) with the spec asserting that exact class. **`Pubid::Iec::UrnParser` has the identical bug and is untouched here.** Also: `Identifier.parse` gained the inline `MAX_INPUT_LENGTH` guard — relaton reaches that class-level funnel directly through `pubid_class:`, bypassing `Pubid::Ietf.parse` — and IETF was added to the three cross-flavor tables it was missing from (`identifier_roundtrip_spec`, `uniform_identifier_handle_spec`, `redos_guard_spec`), which is what exercises the leaf `number` under real multi-flavor load. (hand-off: ietf-index-readiness.)

data/lib/pubid/ietf/builder.rb

@@ -76,3 +76,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Ietf::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/iho/builder.rb

@@ -35,3 +35,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Iho::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/isbn/builder.rb

@@ -42,3 +42,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Isbn::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/iso/CLAUDE.md

@@ -0,0 +1,47 @@
+# ISO flavor notes
+
+- **No identifier attribute holds a `Components::Code` any more**: `number`,
+  `part` and `subpart` on `Pubid::Iso::Identifier`, the committee structure on
+  `Identifiers::TcDocument` (`tc_type`/`tc_number`/`sc_type`/`sc_number`/
+  `wg_type`/`wg_number`), `Identifiers::Directives#subgroup` and the
+  `edition.number` the builder writes are all plain strings, and
+  `Pubid::Iso::Components::Code` is deleted.
+  **The component was degenerate everywhere it was used.** Measured over the
+  whole 7,613-id pass corpus: no ISO Code carries `prefix`, `part`, `subpart`
+  or `parts`, `parts` is never written anywhere in `lib/pubid/iso`, and no Code
+  renders differently from its own `value`. ISO's part and subpart are sibling
+  attributes of the identifier, not fields of the number — the `-` join in
+  `Code#to_s` was unreachable.
+  **`edition.number` was worse than degenerate: it leaked a live object.**
+  `Components::Edition#number` is typed `Lutaml::Model::Type::Value`, so lutaml
+  never serialized it — `to_hash` returned the `Components::Code` instance
+  itself, and `to_yaml` emitted `!ruby/object:Pubid::Components::Code` with its
+  internal ivars, which `YAML.safe_load` refuses. An edition now serializes
+  `{"number" => "13", "original_text" => "Ed 13"}`.
+  **The TC converters are gone with it**: twelve `*_to_kv`/`*_from_kv` helpers
+  were replaced by plain `map "tc_type", to: :tc_type` declarations (the
+  ETSI/OIML shape), because a String needs no converter to flatten.
+  **Two shared surfaces needed a change, and both are the documented shims**:
+  `Renderers::DirectivesRenderer` called `subgroup.render(context:)` directly
+  and now reads through `render_component`; `Pubid::Iso.build_code` returned a
+  Code and now returns the string (ASTM's `to_iso_identifier` goes through it,
+  which is how one ASTM example caught the `NameError` after the class was
+  deleted).
+  **Verification — replay a baseline, do not trust the suite alone.** Against
+  all 7,621 pass-fixture ids captured on the parent commit, `to_s`, `to_urn`,
+  `to_mr_string`, `root.number` and the identifier class are **byte-identical**,
+  and `to_hash` differs for exactly **12** ids: the 9 `subgroup` rows and the 3
+  editions below. The first replay also caught a real regression the specs did
+  not — `directives.rb` still called `part.value.downcase`, so 4 Directives
+  URNs raised.
+  **relaton note — `relaton-data-iso` needs a re-crawl, and only for one key.**
+  `subgroup` flattens from `{"value" => "JTC 1"}` to `"JTC 1"`, and the
+  published `index-v2.yaml` (branch `v2`) carries **5 such rows**, all ISO/IEC
+  JTC 1 directives. **No compatibility shim is kept** — a stored nested
+  `subgroup` will not deserialize. The edition change reaches nothing stored:
+  `grep -c edition` over that index returns **0**.
+  **Spec fallout is the shape to expect for the remaining flavors**: 592
+  assertions across 25 files read `.number.value` / `.part.value`. The rewrite
+  needs a lookbehind, because `tc_number.value` and `edition.number.value` are
+  different attributes — the first pass stripped `edition.number.value` too,
+  and two corrigendum examples caught it.

data/lib/pubid/iso/builder.rb

@@ -58,6 +58,12 @@ module Pubid
       end
 
       def build(parsed_hash)
+        # "(all parts)" and the ":ser" URN name every part of the document,
+        # so they build an AllPartsIdentifier around the document (the URN
+        # parser puts the key on the outermost identifier for the same
+        # reason). The document itself holds no all-parts mark.
+        all_parts = parsed_hash.delete(:all_parts)
+
         # For ISO/R legacy format, split into publisher and type
         if parsed_hash[:iso_r_prefix]
           parsed_hash[:publisher] = "ISO"
@@ -77,14 +83,20 @@ module Pubid
           end
         end
 
-        # Instantiate the identifier based on the typed stage
-        identifier = locate_identifier_klass(parsed_hash).new
-
-        # For French GUIDE entries: "Guide ISO/CEI 37:1995"
+        # For French GUIDE entries: "Guide ISO/CEI 37:1995". The rename
+        # must happen BEFORE class selection — locate_identifier_klass
+        # reads :type_with_stage, and the tree of a guide-first spelling
+        # carries an empty :type_with_stage plus the type under
+        # :type_with_stage_fr, so deferring the rename selected the
+        # default International Standard class for every guide-first
+        # (and Cyrillic "Руководства ИСО …") reference.
         if type_with_stage_fr = parsed_hash.delete(:type_with_stage_fr)
           parsed_hash[:type_with_stage] = type_with_stage_fr
         end
 
+        # Instantiate the identifier based on the typed stage
+        identifier = locate_identifier_klass(parsed_hash).new
+
         # For DirectivesSupplement, rename :publisher to :supplement_publisher
         if identifier.is_a?(Identifiers::DirectivesSupplement) && parsed_hash[:publisher]
           parsed_hash[:supplement_publisher] = parsed_hash.delete(:publisher)
@@ -112,7 +124,7 @@ module Pubid
           identifier.type = default_typed_stage.to_type
         end
 
-        identifier
+        all_parts ? identifier.to_all_parts : identifier
       end
 
       def handle_key(identifier, key, value)
@@ -143,7 +155,7 @@ module Pubid
         return nil unless year_value.between?(1900, 2099)
 
         {
-          number: code_class.new(value: number),
+          number: number,
           date: ::Pubid::Components::Date.new(year: part),
         }
       end
@@ -197,7 +209,7 @@ module Pubid
           # or "105/F" ('F' is part)
           # or "5843/6" ('6' is part)
           # LEGACY: "4037-1979" (number-year, year should become date)
-          parse_number_with_part(value, code_class: Pubid::Iso::Components::Code)
+          parse_number_with_part(value)
 
         when :directives_type
           # nothing to do here, just return nil
@@ -240,8 +252,10 @@ module Pubid
           original_text = value.to_s
           # Extract just the digit(s) for the number field
           number_string = original_text.match(/\d+/)&.to_s
-          number_code = number_string ? Pubid::Iso::Components::Code.new(value: number_string) : nil
-          Pubid::Components::Edition.new(number: number_code,
+          # A plain string: Components::Edition#number is typed Value, so a
+          # component here would leak a live Ruby object into to_hash (and a
+          # !ruby/object tag into to_yaml).
+          Pubid::Components::Edition.new(number: number_string,
                                          original_text: original_text)
 
         when :languages
@@ -260,8 +274,7 @@ module Pubid
 
         when :subgroup
           # Handle JTC 1 subgroup in directives (ISO/IEC JTC 1 DIR)
-          # Store as a component for potential use in rendering
-          Pubid::Iso::Components::Code.new(value: value.to_s)
+          value.to_s
 
         when :supplements
           # Handle bundled supplements (+ operator)
@@ -274,12 +287,10 @@ module Pubid
 
         # TC Document attributes
         when :tc_type, :sc_type, :wg_type
-          # TC, SC, WG types are code components
-          Pubid::Iso::Components::Code.new(value: value.to_s)
+          value.to_s
 
         when :tc_number, :sc_number, :wg_number
-          # TC, SC, WG numbers are code components
-          Pubid::Iso::Components::Code.new(value: value.to_s)
+          value.to_s
 
         when :year
           # For TC documents with year, convert to Date
@@ -290,7 +301,7 @@ module Pubid
           # For regular identifiers, this is handled in :number_with_part
           if value.is_a?(Parslet::Slice) || value.is_a?(String) ||
               value.is_a?(Integer)
-            Pubid::Iso::Components::Code.new(value: value.to_s)
+            value.to_s
           else
             value
           end
@@ -314,3 +325,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Iso::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/iso/components/publisher.rb

@@ -8,6 +8,8 @@ module Pubid
       # ISO Publisher with copublisher support
       # Examples: ISO, ISO/IEC, ISO/IEC/IEEE
       class Publisher < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :publisher, :string, default: -> { "ISO" }
         attribute :copublisher, :string, collection: true
 

data/lib/pubid/iso/components.rb

@@ -3,7 +3,6 @@
 module Pubid
   module Iso
     module Components
-      autoload :Code, "#{__dir__}/components/code"
       autoload :Publisher, "#{__dir__}/components/publisher"
     end
   end

data/lib/pubid/iso/identifier.rb

@@ -11,6 +11,12 @@ module Pubid
       attribute :copublishers, ::Pubid::Iso::Components::Publisher,
                 collection: true
 
+      # ISO prints "(all parts)" and has a series URN, so it has its own
+      # all-parts class.
+      def self.all_parts_class
+        Identifiers::AllParts
+      end
+
       # The publisher implied when none is serialized. ISO for most types;
       # publisher-less types (IWA) override this to nil.
       def self.default_publisher
@@ -56,9 +62,14 @@ module Pubid
         ts ? dup.tap { |id| id.typed_stage = ts } : dup
       end
 
-      attribute :number, ::Pubid::Iso::Components::Code
-      attribute :part, ::Pubid::Iso::Components::Code
-      attribute :subpart, ::Pubid::Iso::Components::Code
+      # Plain strings. Iso::Components::Code existed to join `parts` with
+      # "-", a composition no ISO identifier ever reached: `parts` is never
+      # written in lib/pubid/iso and no Code in the 7,613-id corpus carries
+      # anything but `value`. ISO part and subpart are sibling attributes, not
+      # fields of the number.
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
 
       # Polymorphic type map for lutaml::Model key_value serialization
       # Maps polymorphic_name → class name for deserialization
@@ -132,20 +143,6 @@ module Pubid
         # unique typed-stage `code` under "stage" and recompute the rest on
         # load. _type already pins the document type.
         map "stage", with: { to: :stage_to_kv, from: :stage_from_kv }
-        # Omit the `false` default; only the meaningful `true` is serialized.
-        map "all_parts", with: { to: :all_parts_to_kv, from: :all_parts_from_kv }
-      end
-
-      def all_parts_to_kv(model, doc)
-        return unless model.all_parts
-
-        doc.add_child(
-          Lutaml::KeyValue::DataModel::Element.new("all_parts", true),
-        )
-      end
-
-      def all_parts_from_kv(model, value)
-        model.all_parts = value
       end
 
       # Serialize typed_stage as just its unique code (e.g. "is", "dis",
@@ -213,8 +210,10 @@ module Pubid
         doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, v.to_s))
       end
 
+      # number/part/subpart are plain strings; the converter name is kept
+      # so the key_value map below does not have to change.
       def build_code(value)
-        ::Pubid::Iso::Components::Code.new(value: value.to_s)
+        value.to_s
       end
 
       # --- date serialized flat as year/month/day ---

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      # Every part of one ISO document: "ISO 9000 (all parts)".
+      #
+      # The URN is the series URN: the document URN without its stage, plus
+      # the "ser" slot.
+      class AllParts < ::Pubid::Iso::Identifier
+        include ::Pubid::AllParts
+
+        def to_urn
+          "#{identity.exclude(:stage, :typed_stage).to_urn}:ser"
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,10 @@ module Pubid
   module Iso
     module Identifiers
       class Directives < SingleIdentifier
-        attribute :subgroup, ::Pubid::Components::Code
+        # A plain string ("JTC 1"). The serialized form flattens from
+        # `{"value" => "JTC 1"}` to `"JTC 1"`, so the 5 directives rows of
+        # relaton-data-iso need a re-crawl; no compatibility shim is kept.
+        attribute :subgroup, :string
 
         # Merges with Identifier's block (base attributes); only adds the
         # Directives-specific subgroup so it survives to_hash/from_hash.
@@ -46,15 +49,15 @@ module Pubid
           parts << ([publisher] + copubs).map(&:body).map(&:downcase).join("-")
 
           if subgroup
-            subgroup_parts = subgroup.value.split
+            subgroup_parts = subgroup.split
             parts << subgroup_parts[0].downcase if subgroup_parts[0]
             parts << subgroup_parts[1] if subgroup_parts[1]
           end
 
           parts << "dir"
 
-          parts << number.value if number
-          parts << part.value.downcase if part
+          parts << number.to_s if number
+          parts << part.to_s.downcase if part
           parts << date.year if date
 
           parts.join(":")

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

@@ -89,8 +89,10 @@ format: nil, stage_format_long: nil, with_date: nil, **opts)
         def to_supplement_s(lang: :en, lang_single: false, with_edition: false,
 format: nil, stage_format_long: nil, with_date: nil, **_opts)
           date_str = if date
-                       month_part = date.month ? "-#{date.month}" : ""
-                       ":#{date.render}#{month_part}"
+                       # Components::Date#render already carries the month
+                       # (and day) when present — appending a month_part
+                       # here doubled it (":2016-05-05-05").
+                       ":#{date.render}"
                      else
                        ""
                      end