pubid 2.0.3 → 2.0.5

data/lib/pubid/iho/renderer.rb

@@ -4,33 +4,55 @@ module Pubid
   module Iho
     # Human-readable renderer for IHO identifiers.
     #
-    # Produces strings like:
-    #   "IHO S-44 5.0.0"
-    #   "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)
+    # Canonical faces (owner rulings, 2026-11-03):
+    #   "IHO S-100"                     undated (edition-non-specific)
+    #   "IHO S-100 1.0.0"               dated (edition-specific)
+    #   "IHO S-100 5.0.0 Part 2"        edition BEFORE the part
+    #   "IHO S-98 1.0.0 Part A Annex B"
+    #   "IHO S-122 1.0.0 Appendix D-2"  canonical Appendix, subnumber
+    #                                   joined by a dash
+    #   "IHO M-2 Sup 1"                 canonical Sup (Suppl is an input
+    #                                   alias)
+    #   "IHO P-1 Vol. 30 (2)"           volume-keyed series (P-1, P-6)
+    #   "IHO P-5 Vol. 2024"             the yearbook year IS a volume
+    #   "IHO S-100 5.0.0 Part 2 (2024)" the with-year qualifier: a year
+    #                                   beside an edition is the date
+    #                                   qualifier on standards,
+    #                                   parenthesized — the only year face
     #
     # The renderer is registered as the `:human` format in the IHO format
-    # registry and invoked via `render(format: :human)`.
+    # registry and invoked via `render(format: :human)`; the compact face
+    # (`IHO S-100-1 5.0.0`, `IHO M-2-2`, `IHO P-5/2024`) is the opt-in
+    # `compact: true` flag, and `with_publisher: false` drops the leading
+    # publisher as everywhere else. The legacy faces (glued lettered
+    # bases, Suppl, bare years) parse but are never rendered.
     class Renderer < ::Pubid::Renderers::Base
+      # The canonical component faces in print order: edition BEFORE the
+      # part; each independently-publishable component carries its own
+      # edition (+ parenthesized year) right after it; the appendix joins
+      # its subnumber; the issue rides parenthesized after its volume;
+      # the base year prints only as the parenthesized with-year
+      # qualifier.
+      FACES = [
+        [:edition, " %s"],
+        [:supplement, " Sup %s"], [:supplement_edition, " %s"],
+        [:supplement_year, " (%s)"],
+        [:part, " Part %s"], [:part_edition, " %s"], [:part_year, " (%s)"],
+        [:annex, " Annex %s"], [:annex_edition, " %s"], [:annex_year, " (%s)"],
+        [:appendix, " Appendix %s"], [:appendix_subnumber, "-%s"],
+        [:appendix_edition, " %s"], [:appendix_year, " (%s)"],
+        [:volume, " Vol. %s"], [:issue, " (%s)"],
+        [:volume_edition, " %s"], [:volume_year, " (%s)"],
+        [:year, " (%s)"]
+      ].freeze
+
       def render(context: nil, **opts)
         id = @id
-
-        letter = id.class.type[:short]
-        rendered = "#{id.publisher} #{letter}-#{id.number}"
-        rendered << " Ap. #{id.appendix}" if id.appendix
-        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 = "#{id.publisher} #{id.class.type[:short]}-#{id.number}"
+        FACES.each do |component, face|
+          value = id.public_send(component)
+          rendered << (face % value) if value
+        end
         rendered
       end
     end

data/lib/pubid/iho/urn_generator.rb

@@ -4,16 +4,33 @@ 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}][: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 URN is the documented positional segment grammar (see the
+    # grammar header in pubid-grammar's grammars/iho.parg and the flavor
+    # notes): containment-ordered, one semantic atom per segment, every
+    # non-number component a marker-prefixed segment whose marker is the
+    # lowercased human-face token (edition follows ISO's ed- precedent):
     #
-    # 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.
+    #   urn:iho:<type>:<number>[:ed-<x.y.z>][:sup-<n>][:part-<X>]
+    #     [:annex-<A>][:appendix-<B>][:<sub>][:vol-<n>][:issue-<n>]
+    #     [:year-<yyyy>]
+    #
+    # Containment: part contains annexes, annex contains appendices, the
+    # subnumber is a child atom of its appendix, the issue a child of its
+    # volume. Letters are case-preserved. The volume carries every serial
+    # locator — the yearbook year IS a volume (P-5 Vol. 2024 gives
+    # vol-2024), so a periodical identifier has no year segment; the
+    # year- segment exists only for the standards with-year qualifier.
+    # Both are marker-tagged so neither can collide with a colon-number
+    # segment (the number is not escaped and may span bare segments:
+    # "IHO S-158:100" gives "urn:iho:s:158:100").
+    #
+    # Examples:
+    # - urn:iho:s:44:ed-5.0.0                     IHO S-44 5.0.0
+    # - urn:iho:s:100:ed-5.0.0:part-2:year-2024   IHO S-100 5.0.0 Part 2 (2024)
+    # - urn:iho:s:122:ed-1.0.0:appendix-D:2       IHO S-122 1.0.0 Appendix D-2
+    # - urn:iho:m:2:sup-1                         IHO M-2 Sup 1
+    # - urn:iho:p:5:vol-2024                      IHO P-5 Vol. 2024
+    # - urn:iho:p:1:vol-30:issue-2                IHO P-1 Vol. 30 (2)
     class UrnGenerator
       attr_reader :identifier
 
@@ -21,22 +38,42 @@ module Pubid
         @identifier = identifier
       end
 
+      # [component, marker] pairs in the containment/canonical-face
+      # order. A component edition/year emits right after its component
+      # (the ed- segment attaches to the node it follows, recording the
+      # separately-published mode). nil markers emit their component as
+      # a BARE atom (the appendix subnumber directly after its
+      # appendix).
+      SEGMENTS = [
+        [:edition, "ed"], [:year, "year"],
+        [:supplement, "sup"], [:supplement_edition, "ed"],
+        [:supplement_year, "year"],
+        [:part, "part"], [:part_edition, "ed"], [:part_year, "year"],
+        [:annex, "annex"], [:annex_edition, "ed"], [:annex_year, "year"],
+        [:appendix, "appendix"], [:appendix_subnumber, nil],
+        [:appendix_edition, "ed"], [:appendix_year, "year"],
+        [:volume, "vol"], [:issue, "issue"], [:volume_edition, "ed"],
+        [:volume_year, "year"]
+      ].freeze
+
       def generate
         parts = ["urn", "iho"]
         parts << identifier.class.type[:short].to_s.downcase
         parts << identifier.number.to_s
-        parts << "ap.#{identifier.appendix}"     if identifier.appendix
-        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.concat(component_segments)
         parts.join(":")
       end
+
+      private
+
+      def component_segments
+        SEGMENTS.filter_map do |component, marker|
+          value = identifier.public_send(component)
+          next unless value
+
+          marker ? "#{marker}-#{value}" : value.to_s
+        end
+      end
     end
   end
 end

data/lib/pubid/iho/urn_parser.rb

@@ -2,69 +2,240 @@
 
 module Pubid
   module Iho
-    # Parses IHO URNs back into identifiers.
+    # Parses IHO URNs back into identifiers through the documented
+    # positional segment grammar (the same grammar the generator emits;
+    # the segment table lives in the grammar header and the flavor notes):
     #
-    # UrnGenerator emits:
-    #   urn:iho:{type-lower}:{number}[:{tag}.{value}]*[:{version}][:y.{year}]
+    #   urn:iho:<type>:<number>[:ed-<x.y.z>][:sup-<n>][:part-<X>]
+    #     [:annex-<A>][:appendix-<B>][:<sub>][:vol-<n>][:issue-<n>]
+    #     [:year-<yyyy>]
     #
-    # type-lower is the lowercase series letter (s, p, m, b, c).
-    # 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.
+    # Segment discipline (mirrors the ISO URN parser's strictness):
+    # - the docnumber occupies every leading bare number segment up to
+    #   the first marker, so a colon number ("158:100") round-trips
+    #   without escaping;
+    # - every other component is a marker-prefixed segment validated
+    #   against its own value pattern — unknown, reordered or junk
+    #   segments raise {Pubid::Errors::UrnParseError}, never
+    #   mis-consume;
+    # - the appendix subnumber is a bare digit atom allowed only
+    #   directly after its appendix segment (a year is always
+    #   marker-tagged, so a bare digit there can only be the subnumber);
+    # - the issue is allowed only beside its volume and validated as
+    #   digits.
     #
-    # 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.
+    # Legacy 2.0.x spellings remain decodable but are never emitted:
+    # the bare a.b.c edition segment, the dotted keys part./annex./
+    # suppl./ap./appendix./vol./issue. and the single-letter y. year tag
+    # (the #637 scheme the positional grammar replaces; the legacy
+    # appendix values stored the subnumber inside one string, "D-2",
+    # which decodes into the two components).
     #
     # 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)
+    # - urn:iho:s:44:ed-5.0.0                  → IHO S-44 5.0.0
+    # - urn:iho:s:100:ed-5.0.0:part-2          → IHO S-100 5.0.0 Part 2
+    # - urn:iho:s:122:ed-1.0.0:appendix-D:2    → IHO S-122 1.0.0 Appendix D-2
+    # - urn:iho:p:5:vol-2024                   → IHO P-5 Vol. 2024
+    # - urn:iho:p:1:vol-30:issue-2             → IHO P-1 Vol. 30 (2)
+    # - urn:iho:s:158:100                      → IHO S-158:100
     class UrnParser < Pubid::UrnParser::Base
-      # 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}" },
+      TYPE_LETTERS = %w[s p m b c].freeze
+
+      # Marker => attribute, with the value pattern each marker's slot
+      # accepts. The patterns mirror the grammar's own production rules
+      # (upper-case letters are case-preserved; "part" allows the
+      # digits-then-letters compound like "4a" beside a lone letter; the
+      # volume takes any serial locator, yearbook years included).
+      MARKERS = {
+        "ed" => [:edition, /\A\d+\.\d+\.\d+\z/],
+        "sup" => [:supplement, /\A\d+\z/],
+        "part" => [:part, /\A(?:\d+[a-zA-Z]*|[A-Z]|[SPMBC]-\d+)\z/],
+        "annex" => [:annex, /\A[A-Z]\z/],
+        "appendix" => [:appendix, /\A(?:[A-Z]|\d+)\z/],
+        "vol" => [:volume, /\A\d+\z/],
+        "issue" => [:issue, /\A\d+\z/],
+        "year" => [:year, /\A(?:19|20)\d{2}\z/],
+      }.freeze
+
+      MARKER_RE = /\A(#{MARKERS.keys.join('|')})-(.+)\z/
+
+      # The positional markers: their attribute depends on the node they
+      # follow (the component-edition duality).
+      POSITIONAL_MARKERS = %i[edition year].freeze
+
+      # Legacy dotted keys (deprecated; decodable, never emitted).
+      # "ap" is the pre-positional appendix tag; "suppl" the pre-positional
+      # supplement tag; "y" the pre-positional year tag — under the
+      # serial-locator unification a year IS a volume, so the y. value
+      # decodes into the volume.
+      LEGACY_KEYS = {
+        "part" => :part,
+        "annex" => :annex,
+        "suppl" => :supplement,
+        "ap" => :appendix,
+        "appendix" => :appendix,
+        "vol" => :volume,
+        "issue" => :issue,
+        "y" => :volume,
       }.freeze
 
-      VERSION_SEGMENT = /\A\d+\.\d+\.\d+\z/
+      LEGACY_RE = /\A([a-z]+)\.(.+)\z/
+
+      # A bare a.b.c segment is the legacy edition encoding.
+      LEGACY_EDITION_RE = /\A\d+\.\d+\.\d+\z/
+      SUBNUMBER_RE = /\A\d+\z/
+      # The docnumber's own charset: digits with : / - suffix runs.
+      NUMBER_RE = /\A\d+(?:[:\/-]\d+)*\z/
 
       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}")
+        segments = split_parts(strip_namespace(urn))
+        type_token = read_type!(segments, urn)
+        attrs = { number: consume_number!(segments, urn) }
+        # Positional context: the component the upcoming ed-/year- would
+        # attach to, and the owner of the edition just consumed (a year
+        # belongs to a component only when it follows that component's
+        # own edition).
+        ctx = { component: nil, edition_owner: nil }
+        consume_segments!(attrs, segments, ctx, urn)
+        Builder.build({ type: type_token.upcase, **attrs })
       end
 
       private
 
-      def untagged_number?(segment)
-        !tagged?(segment) && !segment.match?(VERSION_SEGMENT)
+      def read_type!(segments, urn)
+        type_token = segments.shift.to_s.downcase
+        return type_token if TYPE_LETTERS.include?(type_token)
+
+        raise Pubid::Errors::UrnParseError,
+              "Unknown IHO series #{type_token.inspect} in #{urn.inspect}"
+      end
+
+      def consume_segments!(attrs, segments, ctx, urn)
+        until segments.empty?
+          consume_segment!(attrs, segments, ctx, urn)
+        end
+      end
+
+      # The number occupies every leading bare number segment; the first
+      # segment that is not number-shaped ends it (and the segment loop
+      # below decides whether it is a legal marker).
+      def consume_number!(segments, urn)
+        number = []
+        while segments.first&.match?(NUMBER_RE)
+          number << segments.shift
+        end
+        if number.empty?
+          raise Pubid::Errors::UrnParseError,
+                "Missing docnumber in #{urn.inspect}"
+        end
+
+        number.join(":")
+      end
+
+      def consume_segment!(attrs, segments, ctx, urn)
+        segment = segments.shift
+        case segment
+        when MARKER_RE then consume_marker!(segment, attrs, segments, ctx, urn)
+        when LEGACY_RE then consume_legacy!(segment, attrs, urn)
+        when LEGACY_EDITION_RE then store!(attrs, :edition, segment, urn)
+        else raise_unexpected!(segment, urn)
+        end
+      end
+
+      def raise_unexpected!(segment, urn)
+        raise Pubid::Errors::UrnParseError,
+              "Unexpected segment #{segment.inspect} in #{urn.inspect}"
+      end
+
+      # A marker segment: validate the value against the marker's own
+      # pattern, store it, and claim the bare atom that follows an
+      # appendix (its subnumber — the only bare atom allowed after a
+      # marker). The ed- and year- markers are POSITIONAL: the edition
+      # attaches to the component it follows (the base when no component
+      # precedes it), and a year belongs to a component only when it
+      # follows that component's own edition — the separately-published
+      # mode; otherwise it is the base with-year qualifier.
+      def consume_marker!(segment, attrs, segments, ctx, urn)
+        marker, value = MARKER_RE.match(segment).captures
+        key, pattern = MARKERS.fetch(marker)
+        raise_invalid!(marker, value, urn) unless value.match?(pattern)
+
+        if POSITIONAL_MARKERS.include?(key)
+          return consume_positional!(attrs, key, value, ctx, urn)
+        end
+
+        store!(attrs, key, value, urn)
+        ctx[:component] = key
+        ctx[:edition_owner] = nil
+        consume_subnumber!(attrs, key, segments, ctx, urn)
+      end
+
+      def raise_invalid!(marker, value, urn)
+        raise Pubid::Errors::UrnParseError,
+              "Invalid #{marker} value #{value.inspect} in #{urn.inspect}"
+      end
+
+      # ed- and year- are POSITIONAL markers (see the marker docs): the
+      # edition attaches to the component it follows, the year to the
+      # edition owner.
+      def consume_positional!(attrs, key, value, ctx, urn)
+        if key == :edition
+          return store_component_scoped!(attrs, :edition, value, ctx, urn)
+        end
+
+        store_year!(attrs, value, ctx, urn)
+      end
+
+      def store_component_scoped!(attrs, stem, value, ctx, urn)
+        owner = ctx[:component]
+        store!(attrs, owner ? :"#{owner}_#{stem}" : stem, value, urn)
+        ctx[:edition_owner] = owner
       end
 
-      def tagged?(segment)
-        segment.match?(/\A[a-z]+\./i)
+      def store_year!(attrs, value, ctx, urn)
+        owner = ctx[:edition_owner]
+        attrs_key = owner && owner != :base ? :"#{owner}_year" : :year
+        ctx[:edition_owner] = nil
+        store!(attrs, attrs_key, value, urn)
       end
 
-      def segment_text(segment, urn)
-        return " #{segment}" if segment.match?(VERSION_SEGMENT)
+      def consume_subnumber!(attrs, key, segments, ctx, urn)
+        return unless key == :appendix && segments.first&.match?(SUBNUMBER_RE)
+
+        store!(attrs, :appendix_subnumber, segments.shift, urn)
+      end
 
-        tag, value = segment.split(".", 2)
-        render = TAG_TEXT[tag.downcase] if tagged?(segment)
-        unless render
+      # Legacy dotted-key decode. The legacy appendix value stored the
+      # subnumber inside one string ("appendix.D-2"); it decodes into the
+      # two components.
+      def consume_legacy!(segment, attrs, urn)
+        match = LEGACY_RE.match(segment)
+        key = LEGACY_KEYS.fetch(match[1]) do
           raise Pubid::Errors::UrnParseError,
                 "Unexpected segment #{segment.inspect} in #{urn.inspect}"
         end
 
-        render.call(value)
+        store_legacy!(attrs, key, match[2], urn)
+      end
+
+      def store_legacy!(attrs, key, value, urn)
+        sub = /\A([A-Z])-(\d+)\z/.match(value) if key == :appendix
+        return store!(attrs, key, value, urn) unless sub
+
+        store!(attrs, :appendix, sub[1], urn)
+        store!(attrs, :appendix_subnumber, sub[2], urn)
+      end
+
+      def store!(attrs, key, value, urn)
+        raise_if_duplicate(key, attrs, urn)
+        attrs[key] = value
+      end
+
+      def raise_if_duplicate(key, attrs, urn)
+        return unless attrs[key]
+
+        raise Pubid::Errors::UrnParseError,
+              "Duplicate #{key} segment in #{urn.inspect}"
       end
     end
   end

data/lib/pubid/iso/CLAUDE.md

@@ -46,6 +46,38 @@
   different attributes — the first pass stripped `edition.number.value` too,
   and two corrigendum examples caught it.
 
+- **URN item paths and document versions are cut, not parsed (issue #645).**
+  Glossarist-rendered corpora cite parent documents with URNs like
+  `urn:iso:std:iso:10303:-2:ed-1:v1:en:tech:ACTIVITY_MIM` and a duplicated
+  `:tech:X:tech:X:X` extraction tail. Neither tail is document identity, so
+  `UrnParser` drops both: the bare document-version token (`v1` right after
+  `ed-N` — the base identifier has no version attribute, and before this fix
+  the supplement loop consumed it as a type-less supplement number, which
+  wrapped the document as that phantom supplement and collapsed
+  "ISO 10303-2" to "ISO 1"), and the item path, cut at the first
+  supplement-loop token that can be nothing else (`item_path_segment?`).
+  Two invariants to keep when editing this loop:
+  **the cut's allow-list must mirror exactly what the loop consumes** —
+  `stage-`, a bare typed-stage abbr, the `ABBR.N` form, a supplement type,
+  digits, a `\Av\d` version, or a language field (`LANGUAGE_FIELD_RE`,
+  2-3-letter ISO 639 codes, comma-separated). A token allowed through that
+  no branch consumes spins the loop forever: the language branch used to be
+  the loose catch-all that guaranteed progress, and gating it on
+  `LANGUAGE_FIELD_RE` (so item-path segments stop overwriting the base
+  language as a bogus "(ACTIVITY_MIM)" suffix) removed that guarantee —
+  `FDAM.3` in `urn:iso:std:iso:17301:-1:FDAM.3:amd:2022:v1.3` exposed it.
+  That is also why the loop gained an explicit `ABBR.N` arm: the base stage
+  block deliberately skips a supplement-family stage when its own supplement
+  follows, and the loop had to consume the token instead. It is consumed
+  **and dropped** — the supplement layer has no stage-iteration slot, and
+  the old catch-all carried it as a bogus base language visible only in the
+  generated URN (`…:fdam.3:amd:1:2022:v1` → now `…:amd:1:2022:v1`; the
+  locked `to_s` "ISO 17301-1/AMD 1:2022" is unchanged). Net effect:
+  `parse(render(parse(urn)))` round-trips for both item-path forms — the
+  face renders `(EN)` (a form the grammar accepts) instead of the
+  unparseable `(ACTIVITY_MIM)` — and identifiers without an item path
+  render byte-identically. No grammar or renderer change was needed.
+
 - **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

data/lib/pubid/iso/urn_parser.rb

@@ -55,6 +55,12 @@ module Pubid
         "data" => :data,
       }.freeze
 
+      # An ISO 639 language field: 2-3 letter codes, comma-separated
+      # ("en", "fr", "en,fr"). Item-path segments ("tech", "ACTIVITY_MIM")
+      # do not match it and are cut as the URN's item path instead
+      # (issue #645).
+      LANGUAGE_FIELD_RE = /\A[a-zA-Z]{2,3}(?:,[a-zA-Z]{2,3})*\z/
+
       # Parse ISO URN string
       # @param urn [String] URN string to parse
       # @return [Identifier] parsed identifier
@@ -126,12 +132,21 @@ module Pubid
           edition = parts.shift.sub("ed-", "").to_i
         end
 
+        # RFC 5141-bis document version token ("v1" in "…:ed-1:v1:en"). The
+        # base identifier has no version attribute -- the edition is the
+        # version axis -- so the token is dropped here, before the
+        # supplement loop mistakes it for a type-less supplement number,
+        # which wrapped the document as that phantom supplement and
+        # collapsed "ISO 10303-2" to "ISO 1" (issue #645).
+        parts.shift if parts.first&.match?(/\Av\d/)
+
         # Parse language if present (2-letter codes like "en" or comma-separated)
         languages = nil
         if parts.first && !parts.first.match(/^\d+$/) &&
             !parts.first.match?(/^(amd|cor|sup|add|v\d+|stage-|ed-)/i) &&
             !TYPED_STAGE_REVERSE_MAP.key?(parts.first.upcase) &&
-            !parts.first.match?(/^[A-Z]+\.\d+$/i)
+            !parts.first.match?(/^[A-Z]+\.\d+$/i) &&
+            parts.first.match?(LANGUAGE_FIELD_RE)
           languages = parse_languages(parts.shift)
         end
 
@@ -181,6 +196,17 @@ module Pubid
         # Check for supplements (amd, cor, sup, add)
         supplements = []
         while parts.any?
+          # Item path (issue #645): trailing URN segments naming a resource
+          # inside the document ("...:en:tech:ACTIVITY_MIM", and the
+          # Glossarist-era duplicated ":tech:X:tech:X:X" extraction
+          # tails). They are not document identity: the first token that
+          # cannot be a stage, supplement field, version or language
+          # starts the path, and it and everything after it are dropped so
+          # the duplication cannot derail the fields parsed before it.
+          if item_path_segment?(parts.first)
+            break
+          end
+
           supp_type = nil
           supp_number = nil
           supp_version = nil
@@ -194,6 +220,16 @@ module Pubid
           elsif TYPED_STAGE_REVERSE_MAP.key?(parts.first&.upcase)
             supp_stage_abbr = parts.shift.upcase
             supp_stage = TYPED_STAGE_REVERSE_MAP[supp_stage_abbr]
+          elsif parts.first&.match?(/\A[A-Za-z]+\.\d+\z/) &&
+              TYPED_STAGE_REVERSE_MAP.key?(parts.first.upcase.split(".").first)
+            # "FDAM.3" -- a supplement-family stage abbreviation with an
+            # iteration, meant for the supplement that follows
+            # ("...:FDAM.3:amd:..."). The supplement layer has no
+            # stage-iteration slot, so the token is consumed here and
+            # dropped: the previous catch-all language branch carried it
+            # as a bogus base language, surfacing only in the generated
+            # URN (issue #645).
+            parts.shift
           end
 
           # Check for supplement type (amd, cor, sup, add)
@@ -218,8 +254,8 @@ module Pubid
           # the NUMBER. The RFC 5141 additive extension ("amd:1:2007:v2")
           # keeps the number in its own slot, so a v-token after a number
           # is the true <supplversion>.
-          if parts.first&.start_with?("v")
-            version_str = parts.shift.sub("v", "")
+          if parts.first&.match?(/\Av\d/)
+            version_str = parts.shift.delete_prefix("v")
             value = version_str.split(".").first.to_i
             if supp_number.nil?
               supp_number = value
@@ -236,8 +272,8 @@ module Pubid
           # A v-token after the year ("amd:1:2007:v1") would otherwise be
           # left for the next loop iteration, wrapping a type-less
           # supplement around the real one and losing the base.
-          if parts.first&.start_with?("v")
-            version_str = parts.shift.sub("v", "")
+          if parts.first&.match?(/\Av\d/)
+            version_str = parts.shift.delete_prefix("v")
             value = version_str.split(".").first.to_i
             if supp_number.nil?
               supp_number = value
@@ -248,7 +284,9 @@ module Pubid
 
           # Check for language after supplement
           supp_languages = nil
-          if parts.first && !parts.first.match(/^\d+$/) && !parts.first.match?(/^(amd|cor|sup|add|v\d+|stage-)/i)
+          if parts.first && !parts.first.match(/^\d+$/) &&
+              !parts.first.match?(/^(amd|cor|sup|add|v\d+|stage-)/i) &&
+              parts.first.match?(LANGUAGE_FIELD_RE)
             supp_languages = parse_languages(parts.shift)
           end
 
@@ -270,6 +308,25 @@ module Pubid
 
       private
 
+      # True when the token can only be an item-path segment (issue #645):
+      # it is not a stage, supplement type, number/year, version or
+      # language field, so it -- and everything after it -- names a
+      # resource inside the document rather than a component of the
+      # identifier. The allow-list mirrors exactly what the supplement
+      # loop can consume, so every token it lets through makes progress.
+      def item_path_segment?(token)
+        return false if token.nil?
+        return false if token.match?(/\A\d+\z/)
+        return false if token.match?(/\Av\d/)
+        return false if token.start_with?("stage-")
+        return false if TYPED_STAGE_REVERSE_MAP.key?(token.upcase)
+        return false if token.match?(/\A[A-Za-z]+\.\d+\z/) &&
+                        TYPED_STAGE_REVERSE_MAP.key?(token.upcase.split(".").first)
+        return false if SUPPLEMENT_TYPE_MAP.key?(token.downcase)
+
+        !token.match?(LANGUAGE_FIELD_RE)
+      end
+
       # Helper to find IS-type TypedStage by harmonized stage code
       # Used when URN doesn't specify a type code (defaults to IS)
       # Prefers the most specific (non-published) stage

data/lib/pubid/jis/CLAUDE.md

@@ -11,10 +11,15 @@
   jis_identifier`. The WES branch is `"WES" space number parts …` with the same
   tail as JIS (year, `R`, language, 規格群, supplements, SYMBOL) and binds a
   `wes` capture, which the builder keys on. `JIS WES 7700` and `WES X 7700`
-  are rejected: the JIS prefix and a series letter belong only to JIS. The
-  source of record is pubid/pubid-grammar; the artifact was rebaked here with
-  parsanol **1.3.114** — the PATH `parsanol` shim may be a newer version, so
-  bake with the 1.3.114 gem's `exe/parsanol` and check `compiler_version`.
+  are rejected: the JIS prefix and a series letter belong only to JIS.
+- **The artifact is vendored, not baked here.** `data/parg/jis.json` is a
+  verbatim copy of pubid/pubid-grammar `artifacts/jis.json` (main `31fb965`,
+  parsanol **1.3.121**). Change the grammar there and copy the artifact back;
+  `spec/pubid/jis/parg_reaffirmed_spec.rb` pins its `source_hash`, so a local
+  rebake fails that spec.
+- **`reaffirmed` binds the whole run of R's** (`":1997R"` → `"R"`, `":1997RR"`
+  → `"RR"`; same for `amd_reaffirmed`/`corr_reaffirmed`). The builder reads
+  each only for truth (`true if data[:reaffirmed]`), so `RR` renders as `R`.
 - **`series` is nil** for WES (JIS keeps its `""`-coerced String), so the hash
   carries no `series` key. `number` is the bare number (`"7700"`), the index
   key.

data/lib/pubid/parg/backend.rb

@@ -24,7 +24,7 @@ module Pubid
         end
 
         to_builder_hash(Artifact.for(flavor).parse(entry, input), merge: merge_top_sequence)
-      rescue Parsanol::ParseFailed => e
+      rescue *ENGINE_ERRORS => e
         raise Pubid::Errors::ParseError.new(e.message, nil,
                                             input: input,
                                             flavor: registered_name(flavor))