pubid 2.0.2 → 2.0.3

data/lib/pubid/ieee/ire/identifier.rb

@@ -39,7 +39,7 @@ module Pubid
 
         # Parse IRE identifier string
         def self.parse(input)
-          parsed = Pubid::Parg::Backend.parse(:ire, input,
+          parsed = Pubid::Parg::Model.bound(:ire, input,
                                    entry: "ire_identifier")
           builder = Builder.new
           builder.build(parsed)

data/lib/pubid/ieee/nesc/builder.rb

@@ -94,7 +94,7 @@ module Pubid
           return Identifiers::Nesc::Preprint if parsed_hash[:preprint]
 
           # Draft identifiers
-          return Identifiers::Nesc::Draft if parsed_hash[:draft]
+          return Identifiers::Nesc::Draft if parsed_hash[:draft] || parsed_hash[:nesc_draft_marker]
 
           # Variant-based identifiers
           if parsed_hash[:variant]

data/lib/pubid/ieee/project_renderer.rb

@@ -14,8 +14,12 @@ module Pubid
 
       def render(context: nil, **_opts)
         id = @id
+        # Canonical code: a project draft's code is reassembled from
+        # parse-tree captures, and the assembled separators are synthetic
+        # — the printed face is the uniform spelling (the same document
+        # spelled with all dashes or all dots renders identically).
         body = if id.respond_to?(:code_obj) && id.code_obj
-                 id.code_obj.to_s
+                 id.code_obj.canonical_to_s
                else
                  id.number.to_s
                end

data/lib/pubid/ieee/renderer.rb

@@ -472,8 +472,10 @@ module Pubid
                  end
 
         # Code (number) with draft version for PSI — the mark goes after the
-        # code, before the draft and the date.
-        code_part = id.code.to_s
+        # code, before the draft and the date. Canonical code: the PSI
+        # code is reassembled from parse-tree captures (synthetic
+        # separators — see Components::Code#canonical_to_s).
+        code_part = id.code.canonical_to_s
         code_part += mark(id.code_obj&.number, id.code_obj&.prefix,
                           publishers: publishers_of(id))
         if id.draft_obj

data/lib/pubid/ieee/urn_generator.rb

@@ -190,7 +190,10 @@ module Pubid
 
         return nil unless identifier.code_obj
 
-        identifier.code_obj.to_s
+        # The URN is spelling-stable: codes printed with mixed part
+        # separators ("7.4-3-2") share one identity with their uniform
+        # spelling, so the segment renders canonically, not as printed.
+        identifier.code_obj.canonical_to_s
       end
 
       # A multi-designation wrapper (AdoptedStandard, DualPublished,

data/lib/pubid/iho/CLAUDE.md

@@ -62,12 +62,21 @@ and volume/issue only ride part-less ids, which cannot join
 `spec/pubid/all_parts_edition_keys_audit_spec.rb` covers the
 version-bearing S-series collapse.
 
-**URN conventions:** a year is a bare trailing segment
-(`urn:iho:p:5:2024`); a volume is a `vol.N` part-kind segment with an
-optional `issue.N` after it (`urn:iho:p:1:vol.30.issue.2`). The URN
-parser walks part-kind tokens as a run and hands the rebuilt text
-back through the flavor parse, so a URN round-trip exercises the same
-grammar as a string.
+**URN conventions:** only the dotted `version` is an untagged
+segment. A year is tagged `y.N` (`urn:iho:p:5:y.2024`); a volume is a
+`vol.N` segment with an optional `issue.N` segment after it
+(`urn:iho:p:1:vol.30:issue.2`). The URN parser walks the tagged
+segments as a run and hands the rebuilt text back through the flavor
+parse, so a URN round-trip exercises the same grammar as a string.
+**The number is not escaped and can hold a colon** (`IHO S-158:100`
+gives `urn:iho:s:158:100`), so the parser joins every untagged segment
+that is not an a.b.c version back into the number. That is why the
+year must carry a tag: with the bare year that pubid 2.0.2 emitted,
+`IHO S-158:2024` and `IHO S-158 2024` both gave `urn:iho:s:158:2024`,
+and no colon number round-tripped at all. A 2.0.2 year URN such as
+`urn:iho:p:5:2024` now decodes as the number `5:2024`; it was emitted
+only by 2.0.2. A tagged segment with an unknown tag raises
+`Pubid::Errors::UrnParseError`.
 
 ## Fixtures run through the classify pipeline
 

data/lib/pubid/iho/urn_generator.rb

@@ -4,13 +4,16 @@ module Pubid
   module Iho
     # Generates URN strings for IHO identifiers.
     #
-    # Format: urn:iho:{type-letter-lowercase}:{number}[:ap.{appendix}][:part.{part}][:annex.{annex}][:suppl.{supplement}][:{version|year|vol.N[.issue.N]}]
+    # Format: urn:iho:{type-letter-lowercase}:{number}[:ap.{appendix}][:part.{part}][:annex.{annex}][:suppl.{supplement}][:vol.{volume}[:issue.{issue}]][:{version}][:y.{year}]
     # Example: urn:iho:s:44:5.0.0 for "IHO S-44 5.0.0".
-    # The trailing series component follows the flavor's own conventions:
-    # a version or a year is a bare segment ("urn:iho:p:5:2024" for
-    # "IHO P-5 2024"), a volume is a vol.N part-kind segment with an
-    # optional issue.N after it ("urn:iho:p:1:vol.30.issue.2" for
+    # Only the dotted version is a bare segment. A year is tagged
+    # ("urn:iho:p:5:y.2024" for "IHO P-5 2024"), and so is a volume with
+    # its optional issue ("urn:iho:p:1:vol.30:issue.2" for
     # "IHO P-1 Vol. 30 (2)").
+    #
+    # The number is not escaped, so "IHO S-158:100" gives
+    # "urn:iho:s:158:100". A bare year would then make "IHO S-158:2024"
+    # and "IHO S-158 2024" share one URN; the y. tag keeps them apart.
     class UrnGenerator
       attr_reader :identifier
 
@@ -31,7 +34,7 @@ module Pubid
         parts << "vol.#{identifier.volume}"      if identifier.volume
         parts << "issue.#{identifier.issue}"     if identifier.issue
         parts << identifier.version.to_s if identifier.version
-        parts << identifier.year.to_s if identifier.year
+        parts << "y.#{identifier.year}" if identifier.year
         parts.join(":")
       end
     end

data/lib/pubid/iho/urn_parser.rb

@@ -5,63 +5,66 @@ module Pubid
     # Parses IHO URNs back into identifiers.
     #
     # UrnGenerator emits:
-    #   urn:iho:{type-lower}:{number}[:{part-kind}.{part}][:{version|year|vol.N[.issue.N]}]
+    #   urn:iho:{type-lower}:{number}[:{tag}.{value}]*[:{version}][:y.{year}]
     #
     # type-lower is the lowercase series letter (s, p, m, b, c).
-    # part-kind is the lowercase part label (part, ap, annex, suppl,
-    # vol, issue).
-    # The trailing segment is the dotted version, a bare year, or the
-    # volume/issue pair.
+    # tag is a lowercase label: part, ap, annex, suppl, vol, issue or y.
+    # version is the dotted a.b.c edition, the only untagged tail.
+    #
+    # The number is not escaped, so it can span segments
+    # ("IHO S-158:100" gives "urn:iho:s:158:100"). Every untagged
+    # segment that is not a version therefore belongs to the number.
     #
     # Examples:
     # - urn:iho:s:44:5.0.0                → IHO S-44 5.0.0
     # - urn:iho:s:100:part.4a:1.0.0       → IHO S-100 Part 4a 1.0.0
     # - urn:iho:s:65:ap.A:1.0.0           → IHO S-65 Ap. A 1.0.0
-    # - urn:iho:p:5:2024                  → IHO P-5 2024
+    # - urn:iho:s:158:100:1.0.0           → IHO S-158:100 1.0.0
+    # - urn:iho:p:5:y.2024                → IHO P-5 2024
     # - urn:iho:p:1:vol.30                → IHO P-1 Vol. 30
-    # - urn:iho:p:1:vol.30.issue.2        → IHO P-1 Vol. 30 (2)
+    # - urn:iho:p:1:vol.30:issue.2        → IHO P-1 Vol. 30 (2)
     class UrnParser < Pubid::UrnParser::Base
-      PART_LABELS = {
-        "part" => "Part",
-        "ap" => "Ap.",
-        "annex" => "Annex",
-        "suppl" => "Suppl",
-        "vol" => "Vol.",
+      # Tag => the text that the human-readable form prints for it.
+      TAG_TEXT = {
+        "part" => ->(v) { " Part #{v}" },
+        "ap" => ->(v) { " Ap. #{v}" },
+        "annex" => ->(v) { " Annex #{v}" },
+        "suppl" => ->(v) { " Suppl #{v}" },
+        "vol" => ->(v) { " Vol. #{v}" },
+        "issue" => ->(v) { " (#{v})" },
+        "y" => ->(v) { " #{v}" },
       }.freeze
 
+      VERSION_SEGMENT = /\A\d+\.\d+\.\d+\z/
+
       def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
+        type_token, first, *rest = split_parts(strip_namespace(urn))
+        number = [first, *rest.take_while { |s| untagged_number?(s) }]
+        tail = rest.drop(number.size - 1).map { |s| segment_text(s, urn) }
+        flavor_parse("IHO #{type_token.upcase}-#{number.join(':')}#{tail.join}")
+      end
 
-        type_token = parts.fetch(0).upcase
-        number = parts.fetch(1)
-        idx = 2
-        text = "IHO #{type_token}-#{number}"
-        # Part-kind tokens come in any run (a volume may carry an issue
-        # beside it); "issue.N" prints as the parenthesized issue.
-        while parts[idx] && part_kind?(parts[idx])
-          kind, value = parts[idx].split(".", 2)
-          if kind.downcase == "issue"
-            text += " (#{value})"
-          else
-            label = PART_LABELS.fetch(kind.downcase) { kind.capitalize }
-            text += " #{label} #{value}"
-          end
-          idx += 1
-        end
-        tail = parts[idx]
+      private
 
-        text += " #{tail}" if tail
-        flavor_parse(text)
+      def untagged_number?(segment)
+        !tagged?(segment) && !segment.match?(VERSION_SEGMENT)
       end
 
-      private
+      def tagged?(segment)
+        segment.match?(/\A[a-z]+\./i)
+      end
+
+      def segment_text(segment, urn)
+        return " #{segment}" if segment.match?(VERSION_SEGMENT)
+
+        tag, value = segment.split(".", 2)
+        render = TAG_TEXT[tag.downcase] if tagged?(segment)
+        unless render
+          raise Pubid::Errors::UrnParseError,
+                "Unexpected segment #{segment.inspect} in #{urn.inspect}"
+        end
 
-      # A part-kind token starts with letters followed by a dot, e.g.,
-      # "part.4a", "ap.A", "annex.A", "suppl.1". A version like "5.0.0"
-      # starts with a digit.
-      def part_kind?(token)
-        token.match?(/^[a-z]+\./i)
+        render.call(value)
       end
     end
   end

data/lib/pubid/iso/CLAUDE.md

@@ -45,3 +45,69 @@
   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.
+
+- **Typed model bindings (Phase D): the builder consumes the grammar's bound
+  map, not a parse tree.** `Identifier.parse` and `Normalizer` parse through
+  `Pubid::Parg::Model.bound(:iso, …)`; `UrnParser#build_identifier` constructs
+  the same bound-map dialect. The grammar is edition 2 with every
+  builder-consumed capture bound (`grammars/iso.parg`, `bindings identifier`).
+  The conversion preserved byte fidelity: `to_s` and `to_hash` are identical
+  for all 7,859 fixture inputs replayed against a `main` baseline, and the
+  wasm engine agrees with Ruby on every tree and bound map (the
+  `corpus-parity` gate). **What to know before editing either side:**
+
+  - **Supplement layers capture into position-scoped prefixes** — `supp_*`
+    (first supplement), `supp2_*`/`supp3_*` (chain layers), `isor_supp_*`
+    (ISO/R supplement), `dsupp_*` (directive supplement), `bs1_/bs2_/bs3_`
+    (bundle items), `idf_*/idf_supp_*` (the joint's IDF side, whose rules are
+    inlined from the imported idf grammar so the names never collide with the
+    ISO ones). Bindings.collect_captures collects captures globally by name
+    and delivers the FIRST occurrence, so shared names across layers would
+    collapse a layer's number/date onto the base's. `Builder#build` peels the
+    layers outermost-first, re-keying each prefix onto the builder-input
+    names and nesting the rest as the layer's `:base`.
+  - **The base document's own edition captures as `base_edition`** wherever a
+    supplement layer's third_part can carry its own edition
+    (`supplement_base_no_third`, the joint base). The builder re-keys it onto
+    `:edition` only at the innermost base — moving it inside a peel step
+    mis-assigns the edition to the wrapper on multi-layer chains (the
+    `ISO/IEC Guide 98-3 ED1/Suppl 1:2008/Cor 1:2009` spec caught that).
+  - **No array bindings.** The wasm engine's array-group harvest pads
+    non-firing reps with empty hashes (parsanol-ruby#399), so Ruby and wasm
+    bound maps disagree on any input whose parse backtracks past the array
+    branch. Two consequences: copublishers capture as ONE scalar span
+    (`"/IEC/IEEE"`, at-least-one item, absent when none) that the builder
+    splits, and bundle items capture into `bs1_/bs2_/bs3_` prefixes the
+    builder assembles into `supplements`. Verified to hold unchanged at the
+    1.3.121 pin (the capture-flatten release): the re-baked artifact's
+    grammar/entries/bindings/tests/tables are byte-identical to the 1.3.114
+    bake. A newer engine's `(raw)` wrapper interiors would replace both
+    shapes — re-visit when such a wrapper ships.
+  - **The artifact exposes `["identifier", "idf.identifier"]`** — the
+    `use idf` import survives the conversion so the joint composition's
+    entry surface stays available (the fleet gate asserts the entry list).
+    The joint's IDF side itself binds as `idf_*` scalars; the pilot's
+    `publisher -> publisher_name (string) preprocess: publisher_names`
+    binding is also kept (the T1 materialization asserts the full
+    organization name), and the Ruby builder's `cast` returns nil for
+    `:publisher_name` — the Ruby identifier has no such attribute. The
+    Ruby artifact load resolves `use idf` against `data/parg/idf.parg`,
+    which sits beside the vendored artifact.
+  - **Captures must inline their bodies to raw terms.** A capture wrapping a
+    bare rule ref exposes the ref's child nodes and cannot bind as a string
+    (`cannot bind a Array capture`), and date/language bodies are inlined at
+    all capture sites for that reason. Multi-line rules must be brace bodies
+    (line-mode rejects newlines inside groups).
+  - **The URN parser emits the same dialect**: its supplement loop writes
+    `supp_`/`supp2_`/`supp3_`-prefixed flat keys (the prefixes the builder
+    peels), not `{base:, **supp}` nesting; the builder peels `supp_year` and
+    `supp_supplement_version` the same way by prefix. Its raw-stage fallback
+    (`:stage`), `:document_type` and `:supplement_version` keys are
+    builder-input names, not grammar captures, and pass through `cast`
+    unchanged.
+  - **Grammar probes**: `ruby -e 'gem "parsanol", "1.3.121"; …'` against the
+    artifact (`parse_and_bind`) shows the bound map; `Model.bound(:iso, …)`
+    shows the builder's actual input. The artifact and its vendored twin
+    (`data/parg/iso.parg`) must move together — the twin is the embedded
+    source's provenance copy.
+

data/lib/pubid/iso/builder.rb

@@ -66,6 +66,84 @@ module Pubid
         Pubid::Iso.locate_type(typed_stage.type_code)
       end
 
+      # Bound-hash layer fields: the grammar captures every supplement
+      # layer into a disjoint prefix (supp_ on the first supplement,
+      # supp2_ / supp3_ on the chain's later layers, isor_supp_ on an
+      # ISO/R supplement, dsupp_ on a directive supplement), so each
+      # wrapper's fields peel off the flat bound hash by prefix and
+      # re-key onto the builder-input names.
+      SUPPLEMENT_LAYERS = [
+        {
+          prefix: "supp3_",
+          keys: %i[supp3_type_with_stage supp3_number_with_part supp3_stage_iteration
+                   supp3_number supp3_date supp3_undated_marker supp3_edition
+                   supp3_languages supp3_all_parts],
+          plain_third_part: false,
+        },
+        {
+          prefix: "supp2_",
+          keys: %i[supp2_type_with_stage supp2_number_with_part supp2_stage_iteration
+                   supp2_number supp2_date supp2_undated_marker supp2_edition
+                   supp2_languages supp2_all_parts],
+          plain_third_part: false,
+        },
+        {
+          prefix: "supp_",
+          keys: %i[supp_type_with_stage supp_number_with_part supp_stage_iteration
+                   supp_number supp_date supp_undated_marker supp_edition
+                   supp_languages supp_all_parts],
+          # The first supplement's third_part keeps the plain names: the
+          # base document's own edition captures as base_edition, so the
+          # plain edition/languages/all_parts belong to the supplement.
+          plain_third_part: true,
+        },
+        {
+          prefix: "isor_supp_",
+          keys: %i[isor_supp_type_with_stage isor_supp_number_with_part
+                   isor_supp_stage_iteration isor_supp_date isor_supp_undated_marker],
+          plain_third_part: true,
+        },
+      ].freeze
+      PLAIN_THIRD_PART_KEYS = %i[edition languages all_parts].freeze
+
+      # Directive-supplement layer (ISO/IEC DIR 1 ISO SUP): dsupp_* fields
+      # re-key onto the supplement hash, the base directive's fields stay
+      # plain.
+      DSUPP_KEYS = %i[dsupp_publisher dsupp_type_with_stage dsupp_date
+                      dsupp_undated_marker dsupp_edition dsupp_languages
+                      dsupp_all_parts].freeze
+
+      # Bundled directive items capture into position-scoped prefixes
+      # (one per bundle item — the engine's array-group harvest pads
+      # non-firing reps with empty hashes, parsanol-ruby#399, so bundle
+      # items cannot collect through an array binding).
+      BUNDLE_PREFIXES = %w[bs1_ bs2_ bs3_].freeze
+
+      # Joint identifier (ISO x|IDF y): the IDF side captures under idf_*
+      # names; they re-key onto the tree-shape hash Pubid::Idf.build_from_parse
+      # consumes.
+      IDF_KEYS = %i[idf_publisher idf_type_with_stage idf_stage_iteration
+                    idf_number_with_part idf_date idf_languages idf_all_parts
+                    idf_supp_type_with_stage idf_supp_number_with_part2
+                    idf_supp_stage_iteration2 idf_supp_date2
+                    idf_supp_undated_marker].freeze
+      IDF_REKEY = {
+        idf_publisher: :publisher,
+        idf_type_with_stage: :type_with_stage,
+        idf_stage_iteration: :stage_iteration,
+        idf_number_with_part: :number_with_part,
+        idf_date: :date,
+        idf_languages: :languages,
+        idf_all_parts: :all_parts,
+      }.freeze
+      IDF_SUPP_REKEY = {
+        idf_supp_type_with_stage: :type_with_stage,
+        idf_supp_number_with_part2: :number_with_part,
+        idf_supp_stage_iteration2: :stage_iteration,
+        idf_supp_date2: :date,
+        idf_supp_undated_marker: :undated_marker,
+      }.freeze
+
       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
@@ -73,6 +151,51 @@ module Pubid
         # reason). The document itself holds no all-parts mark.
         all_parts = parsed_hash.delete(:all_parts)
 
+        # The copublisher tail captures as one scalar span ("/IEC/IEEE");
+        # split it into the {copublisher:} element hashes the merge and
+        # the :copublishers cast consume. A pre-built array (the URN
+        # parser) passes through.
+        if parsed_hash[:copublishers].is_a?(String)
+          parsed_hash[:copublishers] = parsed_hash.delete(:copublishers)
+            .split("/").map(&:strip).reject(&:empty?)
+            .map { |cp| { copublisher: cp } }
+        end
+
+        # Peel supplement layers outermost-first: each layer re-keys its
+        # prefixed fields onto the builder-input names, nests the rest as
+        # its :base, and re-enters build — the same shape the grammar's
+        # tree used to nest.
+        SUPPLEMENT_LAYERS.each do |layer|
+          next unless parsed_hash.keys.any? do |key|
+            key.to_s.start_with?(layer[:prefix])
+          end
+
+          return build_supplement_layer(parsed_hash, layer, all_parts)
+        end
+
+        # Joint identifier (ISO x|IDF y): the base designation's fields
+        # stay plain, the IDF side re-keys into the tree-shape hash the
+        # IDF builder consumes, and the pair routes through the
+        # CombinedIdentifier via the :joint_identifier key.
+        if parsed_hash.key?(:idf_publisher)
+          return build_joint_identifier(parsed_hash, all_parts)
+        end
+
+        # Directive supplement (ISO/IEC DIR 1 ISO SUP): the dsupp_* fields
+        # are the supplement's, the plain fields its base directive's.
+        if parsed_hash.key?(:dsupp_type_with_stage)
+          return build_directive_supplement(parsed_hash, all_parts)
+        end
+
+        # Bundled directives ("DIR 1:2022 + IEC SUP:2022"): the plain
+        # fields are the base document's; each bundle item captures under
+        # its bs1_/bs2_/bs3_ prefix.
+        if BUNDLE_PREFIXES.any? do |prefix|
+          parsed_hash.keys.any? { |key| key.to_s.start_with?(prefix) }
+        end
+          return build_bundled(parsed_hash, all_parts)
+        end
+
         # For ISO/R legacy format, split into publisher and type
         if parsed_hash[:iso_r_prefix]
           parsed_hash[:publisher] = "ISO"
@@ -80,6 +203,12 @@ module Pubid
           parsed_hash.delete(:iso_r_prefix)
         end
 
+        # The base document's own edition captures as base_edition (the
+        # supplement layers' third_part editions own the plain key), so
+        # it re-keys onto :edition only here — at the innermost base,
+        # after every wrapper layer has been peeled off.
+        parsed_hash[:edition] = parsed_hash.delete(:base_edition) if parsed_hash.key?(:base_edition)
+
         # For NSB-prefixed identifiers (FprISO, WD/ISO), set stage
         if parsed_hash[:nsb_stage]
           nsb_stage = parsed_hash.delete(:nsb_stage)
@@ -94,12 +223,11 @@ module Pubid
 
         # 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)
+        # reads :type_with_stage, and the bound map of a guide-first
+        # spelling carries the type under :type_with_stage_fr, so
+        # deferring the rename selected the default International
+        # Standard class for every guide-first reference.
+        if (type_with_stage_fr = parsed_hash.delete(:type_with_stage_fr))
           parsed_hash[:type_with_stage] = type_with_stage_fr
         end
 
@@ -136,6 +264,89 @@ module Pubid
         all_parts ? identifier.to_all_parts : identifier
       end
 
+      # "ISO 5537|IDF 26": the ISO side builds as the combined
+      # identifier's base, the IDF side re-keys into the tree-shape hash
+      # Pubid::Idf.build_from_parse consumes and lands in
+      # :joint_identifier.
+      def build_joint_identifier(hash, all_parts)
+        base_fields = hash.except(*IDF_KEYS)
+        idf_fields = rekey(hash.slice(*IDF_REKEY.keys), IDF_REKEY)
+
+        if (supp_keys = IDF_SUPP_REKEY.keys & hash.keys).any?
+          idf_fields = {
+            base: idf_fields,
+            **rekey(hash.slice(*supp_keys), IDF_SUPP_REKEY),
+          }
+        end
+
+        inner = { base: base_fields, joint_identifier: idf_fields }
+        inner[:all_parts] = all_parts if all_parts
+        build(inner)
+      end
+
+      # One supplement layer: re-key the layer's prefixed fields, move
+      # the shared plain third-part fields onto the layer where the
+      # grammar captures them there, nest everything else as the layer's
+      # base, and re-enter build.
+      def build_supplement_layer(hash, layer, all_parts)
+        prefix = layer[:prefix]
+        layer_hash = hash.select { |key, _| key.to_s.start_with?(prefix) }
+        fields = rekey_prefix(layer_hash, prefix)
+
+        if layer[:plain_third_part]
+          third_part = hash.slice(*PLAIN_THIRD_PART_KEYS)
+          fields = { **third_part, **fields }
+        end
+
+        rest = hash.except(*layer_hash.keys)
+        rest = rest.except(*PLAIN_THIRD_PART_KEYS) if layer[:plain_third_part]
+
+        inner = { **fields, base: rest }
+        inner[:all_parts] = all_parts if all_parts
+        build(inner)
+      end
+
+      def build_directive_supplement(hash, all_parts)
+        fields = rekey_prefix(hash.slice(*DSUPP_KEYS), "dsupp_")
+        rest = hash.except(*DSUPP_KEYS)
+
+        inner = { **fields, base: rest }
+        inner[:all_parts] = all_parts if all_parts
+        build(inner)
+      end
+
+      # Bundled directives: each bundle item's prefixed fields re-key to
+      # the supplement hash and build a DirectivesSupplement, the plain
+      # fields build the base document, and the pair lands on a
+      # BundledIdentifier.
+      def build_bundled(hash, all_parts)
+        bundle_keys = BUNDLE_PREFIXES.flat_map do |prefix|
+          hash.keys.select { |key| key.to_s.start_with?(prefix) }
+        end
+        supplements = BUNDLE_PREFIXES.filter_map do |prefix|
+          keys = hash.keys.select { |key| key.to_s.start_with?(prefix) }
+          next if keys.empty?
+
+          build(rekey_prefix(hash.slice(*keys), prefix))
+        end
+        identifier = BundledIdentifier.new
+        identifier.base_document = build(hash.except(*bundle_keys))
+        identifier.supplements = supplements
+        all_parts ? identifier.to_all_parts : identifier
+      end
+
+      # Strip a layer prefix from every key ("supp_" / "supp2_" /
+      # "supp3_" / "isor_supp_" / "dsupp_").
+      def rekey_prefix(hash, prefix)
+        hash.to_h do |key, value|
+          [key.to_s.delete_prefix(prefix).to_sym, value]
+        end
+      end
+
+      def rekey(hash, map)
+        hash.to_h { |key, value| [map[key], value] }
+      end
+
       def handle_key(identifier, key, value)
         if key == :joint_identifier
           identifier.additional_identifiers ||= []
@@ -150,8 +361,8 @@ module Pubid
       # "4037/1979", "4037-1979", and "ISO/IEC DIR 1 IEC" all split cleanly.
       def normalize_number_with_part(value)
         value.to_s
-             .tr("#{Parser::DASH_CHARS.join}/", "-")
-             .gsub(" ", "-")
+          .tr("#{Parser::DASH_CHARS.join}/", "-")
+          .gsub(" ", "-")
       end
 
       # LEGACY: "ISO 4037-1979" used a hyphen where the modern form is
@@ -190,7 +401,7 @@ module Pubid
             # (e.g. a TC document, which skips the copublisher merge) matches
             # the [] convention used by copublisher-merged parses and by
             # Identifier.create. Otherwise equality fails on [] vs nil.
-            Pubid::Iso::Components::Publisher.new(publisher: value, 
+            Pubid::Iso::Components::Publisher.new(publisher: value,
                                                   copublisher: [])
           end
 
@@ -285,10 +496,17 @@ module Pubid
           # Handle JTC 1 subgroup in directives (ISO/IEC JTC 1 DIR)
           value.to_s
 
+        when :publisher_name
+          # The grammar's publisher_names preprocess binding (the ISO
+          # organization's full name, consumed by the ts artifact's
+          # schema materialization). The Ruby identifier carries only
+          # the Publisher component, so the field assigns nothing.
+          nil
+
         when :supplements
           # Handle bundled supplements (+ operator)
           # Each supplement is a hash that needs to be built
-          value.map { |supplement_hash| build(supplement_hash[:supplement]) }
+          value.map { |supplement_hash| build(supplement_hash) }
 
         when :base_document
           # For bundled identifiers, build the base document
@@ -301,10 +519,6 @@ module Pubid
         when :tc_number, :sc_number, :wg_number
           value.to_s
 
-        when :year
-          # For TC documents with year, convert to Date
-          Pubid::Components::Date.new(year: value.to_s)
-
         when :number
           # For TC documents, number is the document number (N number)
           # For regular identifiers, this is handled in :number_with_part