pubid 2.0.1 → 2.0.3

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/ietf/identifiers/base.rb

@@ -64,9 +64,25 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Model.bound(:ietf, identifier)
+        parsed = Pubid::Parg::Model.bound(:ietf, strip_prefix(identifier))
         Builder.build(parsed)
       end
+
+      # The external spellings `IETF RFC 8341`, `IETF I-D draft-…`,
+      # `IETF Internet-Draft draft-…`, `Internet-Draft draft-…` and
+      # `I-D draft-…` name the same document as the bare form. The publisher
+      # and the draft label are not part of the identity, so they are dropped
+      # before the baked grammar runs, and `to_s(with_publisher:)` renders
+      # them again. The lookahead keeps the strip off anything that is not
+      # followed by an IETF designation.
+      EXTERNAL_PREFIX = /
+        \A(?:IETF\s+)?(?:(?:I-D|Internet-Draft)\s+(?=draft-))?
+        (?=(?:RFC|BCP|STD|FYI)\s|draft-)
+      /x
+
+      def self.strip_prefix(identifier)
+        identifier.sub(EXTERNAL_PREFIX, "")
+      end
     end
   end
 end

data/lib/pubid/ietf/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Ietf
-    # Parslet grammar for the three IETF families. The top-level alternation is
+    # Grammar for the three IETF families. The top-level alternation is
     # keyed by leading token, and each alternative captures the raw fields the
     # Builder needs:
     #   * RFC        -> { number: }
@@ -12,50 +10,7 @@ module Pubid
     #   * draft      -> { draft_rest: }  (everything after "draft-"; the version
     #                    split is done in the Builder to keep the digit-tail
     #                    heuristic in one place)
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:space) { str(" ") }
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-
-      # "RFC 2119", and the zero-padded, space-less spelling the RFC editor's
-      # rfc-index.xml emits ("RFC0001"). See #subseries for why.
-      rule(:rfc) { str("RFC") >> space.maybe >> digits.as(:number) }
-
-      # "BCP 3" / "STD 66" / "FYI 1".
-      #
-      # The space is optional and leading zeros are allowed because
-      # rfc-index.xml writes the sub-series membership of an RFC in the padded,
-      # space-less form -- <is-also><doc-id>STD0066</doc-id></is-also> -- and
-      # relaton builds the STD/BCP/FYI <-> RFC cross-references from exactly
-      # those elements without normalizing them itself. The Builder strips the
-      # pad, so the printed form stays the canonical "STD 66".
-      rule(:subseries) do
-        (str("BCP") | str("STD") | str("FYI")).as(:series) >>
-          space.maybe >> digits.as(:number)
-      end
-
-      # Internet-Draft slug characters: lowercase, digits and the "-", "+", "_"
-      # separators, plus two historical shapes the published corpus carries --
-      # a dot inside a topic token ("draft-ietf-pilc-2.5g3g-12") and uppercase
-      # letters in protocol/organisation names ("draft-chapin-clnp-ISO8473-00").
-      # 50 of the 166,740 relaton-data-ids identifiers need those two
-      # characters; nothing else outside [a-z0-9-] occurs in the corpus.
-      #
-      # Widening the tail is unambiguous: the top-level alternation is keyed on
-      # the leading token (RFC / BCP|STD|FYI / draft-), so a wider draft tail
-      # cannot make another branch match.
-      #
-      # The whole remainder after "draft-" is captured; the Builder anchors the
-      # optional trailing "-NN" version.
-      rule(:draft_rest) { match['a-zA-Z0-9+_.\-'].repeat(1).as(:draft_rest) }
-      rule(:draft) { str("draft-") >> draft_rest }
-
-      rule(:identifier) { rfc | subseries | draft }
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/ietf/renderer.rb

@@ -8,10 +8,25 @@ module Pubid
     #   "RFC 2119"
     #   "BCP 3" / "STD 66" / "FYI 1"
     #   "draft-giuliano-treedn-02" / "draft-giuliano-treedn"
+    #
+    # The default form carries no publisher, which is how IETF documents are
+    # cited. `with_publisher:` names the two forms relaton#49 asks for:
+    #   true  -> "IETF RFC 2119" / "IETF Internet-Draft draft-giuliano-treedn"
+    #   false -> "RFC 2119"      / "Internet-Draft draft-giuliano-treedn"
+    # A draft slug says nothing about its type, so both explicit forms label
+    # it; the default keeps the bare slug.
     class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **_opts)
+      INTERNET_DRAFT_LABEL = "Internet-Draft"
+
+      def render(context: nil, with_publisher: nil, **_opts)
         require_number!(@id)
-        render_identifier(@id)
+        result = render_identifier(@id)
+        return result if with_publisher.nil?
+
+        if @id.is_a?(Identifiers::InternetDraft)
+          result = "#{INTERNET_DRAFT_LABEL} #{result}"
+        end
+        with_publisher ? "#{Identifier::PUBLISHER} #{result}" : result
       end
 
       private

data/lib/pubid/iho/CLAUDE.md

@@ -0,0 +1,98 @@
+# IHO flavor notes
+
+IHO (International Hydrographic Organization) identifiers: the
+S/P/M/B/C letter series, their parg-driven parse, and the series
+components introduced for relaton/relaton#407.
+
+Read this before you change `lib/pubid/iho/` or `spec/pubid/iho/`. The
+root `CLAUDE.md` keeps the cross-flavor contract that every flavor
+obeys.
+
+## Parsing runs on the parg artifact
+
+There is no `parser.rb` and no Parslet anywhere in this flavor: parse
+goes `Pubid::Parg::Backend.parse(:iho, ...)` over the baked artifact
+`data/parg/iho.json`. The artifact is baked from the flavor grammar
+source `grammars/iho.parg` in the pubid-grammar repository (commit
+840b2b1d "Retire the last live Parslet parsers" ports the original
+13-rule Parslet grammar byte-identically).
+
+**Drift warning:** the artifact on this branch carries the
+relaton/relaton#407 tail rules (year / volume / issue), while the
+checked-in `grammars/iho.parg` in pubid-grammar still has only the
+version tail. Until the updated grammar source lands in pubid-grammar,
+the artifact is ahead of its source and not reproducible from it —
+the same artifact-ahead-of-source state the root notes describe under
+grammar-artifact drift. Do not re-bake from the stale source, and do
+not hand-edit the artifact; land the grammar first.
+
+## Series components (relaton/relaton#407)
+
+The B-7, P-1, P-5, P-6 series are continuously updated publications
+whose trailing component is not an a.b.c edition: P-5/P-6 (and B-7)
+are identified by **year**, P-1 (the International Hydrographic
+Review) by **volume** with an optional **issue**. The grammar tail
+picks exactly one discriminator, so only one of `version` / `year` /
+`volume` is ever present, with `issue` only beside a volume:
+
+- `IHO P-5 2024` — year is a plain `:string` scalar, 19xx/20xx only
+  (`IHO P-5 1850` and the two-segment `IHO B-12 3.0` reject).
+- `IHO P-1 Vol. 30 (2)` — volume/issue scalars; `Issue 2` is an input
+  alias whose canonical print is `(2)`.
+- `IHO S-44 5.0.0` — the dotted `version` stays for the edition-bearing
+  series and legacy `1.0.0` placeholder rows.
+
+All three are ordinary lutaml attributes mapped through the flavor's
+`key_value` block — no converters, no hand-rolled serialization.
+
+**Identity semantics:** the components are identity-bearing in `==` /
+`matches?`; a bare reference (`IHO P-5`) leaves all four nil and
+wildcards the series (`spec/pubid/partial_ref_spec.rb` locks the
+omitted-key set). The volume/issue pair is a scalar **cluster**:
+`exclude(:volume)` nils the issue with it, so a reference that omits
+the issue still matches a hit that carries one — the same
+additive-alias shape the base applies to `:year -> :date`. A lone
+scalar `:year` needs no override; the base nils a declared `:year`
+directly.
+
+**`all_parts_edition_keys` needs no override:** the default
+`%i[date year edition version]` already covers `:year` and `version`,
+and volume/issue only ride part-less ids, which cannot join
+`AllParts` (`validate_member!` demands a `part`). The audit case in
+`spec/pubid/all_parts_edition_keys_audit_spec.rb` covers the
+version-bearing S-series collapse.
+
+**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
+
+`spec/fixtures/iho/identifiers/full/identifiers.txt` is the input
+corpus; `rake "validation:classify[iho]"` regenerates `pass/` and
+`fail/` from it (the classifier deletes pass/fail first — never edit
+them by hand, edit `full/` and reclassify). Before the relaton#407
+branch the pass files were hand-curated with **no** `full/` tree, the
+OASIS hazard: a classify run would have wiped 131 entries and rebuilt
+nothing. The classifier's per-flavor class detection has an `iho`
+case, so fail entries land in a named class file.
+
+## relaton-side follow-ups (not this repo)
+
+relaton/relaton#407 items 3-4 stay open on the relaton side:
+`Relaton::Iho::Bibliography#pubid_match?`/`version_key` need the new
+component, relaton-cli's `MachineIndex::REFINABLE_KEYS` needs
+`year`/`volume` beside `version`/`edition`, and the pubid pin bumps
+in step with the relaton-data-iho re-key.

data/lib/pubid/iho/builder.rb

@@ -2,7 +2,7 @@
 
 module Pubid
   module Iho
-    # Build IHO identifier objects from parslet parse output.
+    # Build IHO identifier objects from the parg artifact parse tree.
     class Builder
       def build(parsed)
         hash = parsed.is_a?(Array) ? parsed.reduce({}, :merge) : parsed
@@ -15,6 +15,9 @@ module Pubid
           annex: stringify(hash[:annex]),
           supplement: stringify(hash[:supplement]),
           version: stringify(hash[:version]),
+          year: stringify(hash[:year]),
+          volume: stringify(hash[:volume]),
+          issue: stringify(hash[:issue]),
         }.compact
 
         Pubid::Iho.identifier_klass_for_type_letter(type_letter).new(**attrs)

data/lib/pubid/iho/identifiers/base.rb

@@ -6,7 +6,7 @@ module Pubid
     # every concrete IHO identifier (Identifiers::*) descends from it.
     #
     # IHO identifiers have the form:
-    #   IHO {S|P|M|B|C}-{number}[ Ap. {appendix}][ Part {part}][ Annex {annex}][ Suppl {supplement}][ {version}]
+    #   IHO {S|P|M|B|C}-{number}[ Ap. {appendix}][ Part {part}][ Annex {annex}][ Suppl {supplement}][ {version|year|Vol. N [issue]}]
     #
     # The leading IHO publisher prefix is optional on input but always
     # emitted on output.
@@ -25,7 +25,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(identifier)
+        parsed = Pubid::Parg::Backend.parse(:iho, identifier.strip)
         Builder.build(parsed)
       end
 
@@ -40,6 +40,17 @@ module Pubid
       attribute :annex,      :string
       attribute :supplement, :string
       attribute :version,    :string
+      # Series identity components (relaton#407): the year-identified
+      # series (B-7, P-5, P-6) and the volume/issue-identified ones
+      # (P-1 and the IHR) carry no a.b.c edition — their trailing
+      # component is a year or a "Vol. N [issue]" pair instead. Plain
+      # scalars, like every other IHO attribute; the grammar's tail
+      # picks exactly one discriminator, so only one of
+      # version/year/volume is ever present, with issue only
+      # alongside volume.
+      attribute :year,       :string
+      attribute :volume,     :string
+      attribute :issue,      :string
 
       # Polymorphic type map for lutaml::Model key_value serialization: maps
       # each subclass's polymorphic_name to its class name so `from_hash` can
@@ -65,10 +76,25 @@ module Pubid
         map "annex",      to: :annex
         map "supplement", to: :supplement
         map "version",    to: :version
+        map "year",       to: :year
+        map "volume",     to: :volume
+        map "issue",      to: :issue
       end
 
       # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
       # IHO_TYPE_MAP remains as the key_value polymorphic_map.
+
+      # The volume/issue pair is a scalar cluster: a reference that omits
+      # the issue must still match a hit that carries one ("P-1 Vol. 30"
+      # vs "P-1 Vol. 30 (2)"), so excluding the volume nils the issue
+      # with it — the same additive-alias shape the base applies to
+      # :year -> :date. A lone scalar :year needs no override here: the
+      # base nils a declared :year directly (the additive :year -> :date
+      # alias nils whichever name the flavor declares).
+      def exclude(*args)
+        args << :issue if args.include?(:volume)
+        super
+      end
     end
 
   end

data/lib/pubid/iho/renderer.rb

@@ -9,6 +9,8 @@ module Pubid
     #   "IHO P-1/21 1.0.0"
     #   "IHO S-100 Part 4a 1.0.0"
     #   "IHO S-65 Ap. A 1.0.0"
+    #   "IHO P-5 2024"            (year-identified series)
+    #   "IHO P-1 Vol. 30 (2)"     (volume/issue-identified series)
     #
     # The renderer is registered as the `:human` format in the IHO format
     # registry and invoked via `render(format: :human)`.
@@ -22,7 +24,13 @@ module Pubid
         rendered << " Part #{id.part}" if id.part
         rendered << " Annex #{id.annex}" if id.annex
         rendered << " Suppl #{id.supplement}" if id.supplement
+        # The grammar's tail picks exactly one discriminator: a dotted
+        # version, a year, or a volume (with an optional issue). The
+        # issue prints parenthesized; "Issue N" is an input alias only.
         rendered << " #{id.version}" if id.version
+        rendered << " #{id.year}" if id.year
+        rendered << " Vol. #{id.volume}" if id.volume
+        rendered << " (#{id.issue})" if id.issue
         rendered
       end
     end

data/lib/pubid/iho/urn_generator.rb

@@ -4,8 +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}]
+    # 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".
+    # 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
 
@@ -21,7 +29,12 @@ module Pubid
         parts << "part.#{identifier.part}"       if identifier.part
         parts << "annex.#{identifier.annex}"     if identifier.annex
         parts << "suppl.#{identifier.supplement}" if identifier.supplement
+        # The grammar's tail picks exactly one discriminator; a volume
+        # may carry an issue beside it.
+        parts << "vol.#{identifier.volume}"      if identifier.volume
+        parts << "issue.#{identifier.issue}"     if identifier.issue
         parts << identifier.version.to_s if identifier.version
+        parts << "y.#{identifier.year}" if identifier.year
         parts.join(":")
       end
     end

data/lib/pubid/iho/urn_parser.rb

@@ -5,53 +5,66 @@ module Pubid
     # Parses IHO URNs back into identifiers.
     #
     # UrnGenerator emits:
-    #   urn:iho:{type-lower}:{number}[:{part-kind}.{part}]:{version}
+    #   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).
-    # version is the dotted version string.
+    # 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: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)
     class UrnParser < Pubid::UrnParser::Base
-      PART_LABELS = {
-        "part" => "Part",
-        "ap" => "Ap.",
-        "annex" => "Annex",
-        "suppl" => "Suppl",
+      # 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
 
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-
-        type_token = parts.fetch(0).upcase
-        number = parts.fetch(1)
-        idx = 2
-        part_label = nil
-        if parts[idx] && part_kind?(parts[idx])
-          kind, value = parts[idx].split(".", 2)
-          label = PART_LABELS.fetch(kind.downcase) { kind.capitalize }
-          part_label = "#{label} #{value}"
-          idx += 1
-        end
-        version = parts[idx]
+      VERSION_SEGMENT = /\A\d+\.\d+\.\d+\z/
 
-        text = "IHO #{type_token}-#{number}"
-        text += " #{part_label}" if part_label
-        text += " #{version}" if version
-        flavor_parse(text)
+      def parse_urn(urn)
+        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
 
       private
 
-      # 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)
+      def untagged_number?(segment)
+        !tagged?(segment) && !segment.match?(VERSION_SEGMENT)
+      end
+
+      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
+
+        render.call(value)
       end
     end
   end

data/lib/pubid/iho.rb

@@ -11,7 +11,6 @@ module Pubid
     autoload :Builder,      "#{__dir__}/iho/builder"
     autoload :Identifier, "#{__dir__}/iho/identifiers/base"
     autoload :Identifiers,  "#{__dir__}/iho/identifiers"
-    autoload :Parser,       "#{__dir__}/iho/parser"
     autoload :Renderer,     "#{__dir__}/iho/renderer"
     autoload :UrnGenerator, "#{__dir__}/iho/urn_generator"
     autoload :UrnParser, "#{__dir__}/iho/urn_parser"

data/lib/pubid/isbn/identifier.rb

@@ -64,7 +64,7 @@ module Pubid
 
       # @raise [Pubid::Errors::ParseError] if the string is not a valid ISBN
       def self.build_identifier(identifier)
-        parsed = Pubid::Parg::Backend.parse(:isbn, identifier)
+        parsed = Pubid::Parg::Model.bound(:isbn, identifier)
         Builder.build(parsed)
       rescue ArgumentError => e
         # The Builder validates length and check digit. Surface that as a parse

data/lib/pubid/isbn/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Isbn
-    # Parslet grammar for ISBN identifiers per ISO 2108.
+    # Grammar for ISBN identifiers per ISO 2108.
     #
     # Accepts:
     #   [ISBN[ |:]] {10 or 13 digits with optional hyphens}
@@ -12,34 +10,7 @@ module Pubid
     # ISBN-10 final digit may be "X" (check digit value 10). Hyphens are
     # optional and may appear in any group position; they are preserved
     # for round-trip rendering.
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:space)   { str(" ") }
-      rule(:colon)   { str(":") }
-      rule(:hyphen)  { str("-") }
-      rule(:digit)   { match("[0-9]") }
-      rule(:x_digit) { digit | str("X") }
-
-      rule(:isbn_prefix) do
-        (str("ISBN") >> (space | (space.maybe >> colon >> space.maybe))).maybe
-      end
-
-      rule(:digit_group) { digit.repeat(1) }
-      rule(:x_group)     { x_digit.repeat(1) }
-
-      # Loose "ISBN-ish" token: digits or final X, separated by hyphens.
-      rule(:isbn_body) do
-        (digit_group >> (hyphen >> digit_group).repeat >>
-          (hyphen >> x_digit).maybe).as(:body) |
-          (digit.repeat(9, 12) >> x_digit.maybe).as(:body)
-      end
-
-      rule(:identifier) { isbn_prefix >> isbn_body }
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     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.
+