pubid 2.0.23 → 2.0.25

data/lib/pubid/cen_pfs.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+#
+# PFS-generated flavor — DO NOT EDIT BY HAND.
+# Source: definitions/cen.pfs (pfs:1) sha256:bc1edd5874f8938b5f946416a2b052d9d9b9df3d99f6c20a3d88fcab9ae1d70c
+# Compiler: pubid/grammar/pfs 0.1.0 (baked with parsanol 1.3.126)
+# Regenerate: ruby scripts/pfs compile definitions/cen.pfs --as cen_pfs --ruby-out <dir>
+
+require "pubid"
+
+module Pubid
+  # CEN/CENELEC European Norms (module composition) flavor, compiled from its PFS definition
+  # (pubid/pubid#706). A compiled flavor is a peer of the coded
+  # flavors: same registry, same input guards, same error
+  # namespace, same URN contracts.
+  module CenPfs
+    extend Pubid::PrefixesSupport
+
+    PREFIXES = ["EN", "CEN/", "CLC/"].freeze
+    # The module composition the definition binds (issue #706 §4):
+    # each entry names the library module, the version it was bound
+    # at, and — where the module declares one — its IDENTITY
+    # composition (wrapper-with-adopted: the adopted document is
+    # the base). Carried so consumers and the wizard can
+    # introspect what the flavor is composed of.
+    MODULES = [
+      { name: "iso.inner", version: 1, identity: { composition: "wrapper-with-adopted", base_module: "iso.inner", adopted_field: :adopted } },
+      { name: "en.overlay", version: 1, identity: { composition: "wrapper-with-adopted", base_module: "iso.inner", adopted_field: :adopted } },
+      { name: "national.prefix", version: 1, identity: { composition: "wrapper-with-adopted", base_module: "iso.inner", adopted_field: :adopted } },
+      { name: "supplements.core", version: 1, identity: { composition: "wrapper-with-adopted", adopted_field: :base } },
+    ].freeze
+
+    autoload :Builder, "#{__dir__}/cen_pfs/builder"
+    autoload :Identifier, "#{__dir__}/cen_pfs/identifier"
+    autoload :Identifiers, "#{__dir__}/cen_pfs/identifiers"
+    autoload :Parser, "#{__dir__}/cen_pfs/parser"
+    autoload :Renderer, "#{__dir__}/cen_pfs/renderer"
+    autoload :PubidUrnSchema, "#{__dir__}/cen_pfs/pubid_urn_schema"
+    autoload :UrnGenerator, "#{__dir__}/cen_pfs/urn_generator"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: CenPfs::Renderer)
+
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
+      end
+    end
+
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+Pubid::Registry.register(:cen_pfs, Pubid::CenPfs)

data/lib/pubid/doi_pfs/identifier.rb

@@ -14,7 +14,14 @@
           map "suffix", to: :suffix
         end
 
-        PUBLISHER = "DOI".freeze
+        PUBLISHER = "DOI"
+
+        # The scheme's declared publisher token: the internal-form
+        # cut (to_s(with_publisher: false)) strips it from the
+        # rendered face.
+        def publisher_prefixes
+          [PUBLISHER]
+        end
 
         def self.parse(identifier)
           unless identifier.is_a?(String)

data/lib/pubid/doi_pfs.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 #
 # PFS-generated flavor — DO NOT EDIT BY HAND.
 # Source: definitions/doi.pfs (pfs:1) sha256:60abc3c403c61019d727ee44d9a72591c1549672451e6609a72d36189cae6340
@@ -17,6 +16,7 @@ module Pubid
     extend Pubid::PrefixesSupport
 
     PREFIXES = ["doi:", "DOI:", "10."].freeze
+    
 
     autoload :Builder, "#{__dir__}/doi_pfs/builder"
     autoload :Identifier, "#{__dir__}/doi_pfs/identifier"
@@ -35,11 +35,7 @@ module Pubid
 
     def self.identifier_types
       @identifier_types ||= Identifiers.constants
-        .filter_map do |c| 
-        
-        Identifiers.const_get(c); rescue NameError; nil 
-        
-      end
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
         .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
         .select { |c| c.type.is_a?(Hash) }
     end
@@ -56,11 +52,7 @@ module Pubid
 
     def self.locate_stage(abbr)
       abbr_str = abbr.to_s.upcase
-      all_typed_stages.find do |s| 
-        s.abbr.any? do |a|
-          a.to_s.upcase == abbr_str
-        end
-      end
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
     end
   end
 end

data/lib/pubid/etsi_pfs/CLAUDE.md

@@ -0,0 +1,95 @@
+# EtsiPfs — the PFS-compiled etsi dev alias
+
+This flavor is **generated**, not hand-written: every file here is compiler
+output from `pubid-grammar`'s `definitions/etsi.pfs` (pubid/pubid#706
+phase 2), reproduce with
+
+```bash
+cd ../pubid-grammar
+ruby scripts/pfs compile definitions/etsi.pfs --as etsi_pfs \
+  --parsanol-version <CI pin> --ruby-out ../pubid/lib
+mv ../pubid/lib/etsi_pfs.rb ../pubid/lib/pubid/etsi_pfs.rb   # __dir__ paths assume lib/pubid/
+mv ../pubid/lib/etsi_pfs ../pubid/lib/pubid/etsi_pfs
+cp artifacts/etsi_pfs.json ../pubid/data/parg/etsi_pfs.json
+```
+
+DO NOT EDIT these files by hand — a hand edit is silently overwritten by
+the next compile, and the grammar SSOT is the definition, not this module
+(the `data/parg/etsi_pfs.json` artifact's freshness envelope and the
+definition's source sha pin the lineage).
+
+## The coexistence semantics (read before touching anything)
+
+`etsi_pfs` is the **dev-alias key** of the etsi scheme: it registers beside
+the coded `Pubid::Etsi` so the compiled pipeline can be proven against the
+coded flavor without cutover. Same rules as `lib/pubid/doi_pfs/CLAUDE.md`:
+the definition declares the scheme-canonical wire tag
+(`pubid:etsi:etsi-standard`) and the scheme's `to_urn` namespace (`etsi`);
+`Pubid.parse` keeps routing `ETSI …` to the coded flavor.
+
+## The parity gate
+
+`spec/pubid/etsi_pfs/parity_spec.rb` is the deliverable: over the FULL
+fixture inventory (24,718 pass fixtures — the largest corpus a compiled
+flavor is bracketed against) plus constructed edge cases and 23 negatives.
+Measured surface (see the spec header for the numbers and their meaning):
+
+- **accept 24,718/24,718** and the same `ParseError` on negatives — the
+  language bracket: the compiled grammar accepts exactly the coded surface
+  (all 15 type tokens; the four number shapes GSM/dotted/complex/simple;
+  minor; the parts run; the /A//C supplement runs; `V`-versions and
+  `ed.N`; the `(YYYY-MM)` date).
+- **to_hash and to_pubid_urn byte parity: 18,945/24,718** — exactly the
+  rows carrying none of the three constructs pfs:1 cannot declare. Each
+  gap is pinned per construct in the spec, so compiler progress turns the
+  pin red:
+  1. **collection bindings** — the coded model stores `["1","0"]` (the
+     `part -> parts[].part` binding); the compiled capture is the printed
+     dash run `"-1-0"`.
+  2. **the edition face** — the coded model folds `ed.N` into
+     `Version(version: "N", is_edition: true)`; the compiled hash carries
+     `edition: "N"`.
+  3. **supplement wrappers** — the coded model wraps `/A1` `/C1` as
+     Amendment/Corrigendum classes with an Integer ordinal delegating to
+     their base; the compiled row stays a flat etsi-standard carrying the
+     printed run `"/A1"`.
+- **to_s** renders the canonical CORE face (`ETSI <type> <number>`) —
+  pfs:1 render faces cannot render optionals, so every corpus row (all of
+  which carry version/ed + date) renders shorter; bare ids agree
+  byte-for-byte.
+- **to_urn** is a compiler gap (the coded generator is hand-written Ruby
+  composing `urn:etsi:{type}:{code}:{version}:{date}`; the generated
+  generator pins the namespace only). Note the CODED generator raises
+  `ArgumentError` on months 08/09 (`format('%02d', "08")` — the zero-padded
+  string reads as an invalid octal); pre-existing on main, pinned by the
+  parity spec.
+- **to_mr_string** is a compiler gap (the coded slug reads the flavor's
+  `mr_*` hooks — type/parts/edition/date segments; the base hooks find
+  none of them on the compiled columns).
+
+## Non-obvious facts, learned the hard way
+
+- The generated `--ruby-out` lands at `lib/etsi_pfs.rb`; the autoload and
+  the `#{__dir__}` paths require it at `lib/pubid/etsi_pfs.rb` — move both
+  the file and the directory (commands above).
+- `core: ["number"]` in a `.pfs` urn type row would generate
+  `core: [:number]`, which crashes `PubidUrn.define` at load time (the
+  generator emits `core.map(&:to_sym)`); only `core: []` round-trips.
+  The instance's URNs resolve through the CODED schema anyway (the flavor
+  segment of the canonical tag is `etsi`), so the alias rows are the
+  future-cutover shape.
+- `V1..1` parses in BOTH flavors (`.` is a version_char) and `GS` is a
+  real type token — neither is a parity negative.
+- `Pubid::EtsiPfs.parse("ETSI …")` never hijacks `Pubid.parse` (registry
+  keys sort `"etsi"` first), and `Pubid.from_hash` of an alias hash
+  resolves the coded `EtsiStandard` (one scheme, one `_type`).
+- The corpus inventory (`spec/fixtures/etsi/identifiers/full/`) is the
+  parity source; its bucket split is pinned: plain 18,945 / parts 3,772 /
+  edition 1,833 / supplement 168.
+
+## v1 boundaries
+
+Single-type schemes only, `kind: string` fields only, no free-standing
+`stages:`/`supplements:` sections, no semantic decode rules — see
+`pubid-grammar`'s `definitions/README.md` for the language reference and
+the fail-closed validation rules.

data/lib/pubid/etsi_pfs/builder.rb

@@ -0,0 +1,25 @@
+  module Pubid
+    module EtsiPfs
+      class Builder
+        def self.build(parsed_data)
+          new.build(parsed_data)
+        end
+
+        def build(data)
+          Identifiers::Standard.new(
+          type: data[:type],
+          number: data[:number],
+          minor: data[:minor],
+          parts: data[:parts],
+          supplements: data[:supplements],
+          version: data[:version],
+          edition: data[:edition],
+          year: data[:year],
+          month: data[:month],
+          )
+        end
+      end
+    end
+  end
+
+  Pubid::EtsiPfs::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/etsi_pfs/identifier.rb

@@ -0,0 +1,50 @@
+  module Pubid
+    module EtsiPfs
+      class Identifier < ::Pubid::Identifier
+        attribute :type, :string
+        attribute :number, :string
+        attribute :minor, :string
+        attribute :parts, :string
+        attribute :supplements, :string
+        attribute :version, :string
+        attribute :edition, :string
+        attribute :year, :string
+        attribute :month, :string
+
+        ETSI_TYPE_MAP = {
+          "pubid:etsi:etsi-standard" => "Pubid::EtsiPfs::Identifiers::Standard",
+        }.freeze
+
+        key_value do
+          map "_type", to: :_type, polymorphic_map: ETSI_TYPE_MAP
+          map "type", to: :type
+          map "number", to: :number
+          map "minor", to: :minor
+          map "parts", to: :parts
+          map "supplements", to: :supplements
+          map "version", to: :version
+          map "edition", to: :edition
+          map "year", to: :year
+          map "month", to: :month
+        end
+
+        PUBLISHER = "ETSI"
+
+        def self.parse(identifier)
+          unless identifier.is_a?(String)
+            raise Pubid::Errors::InvalidInputError,
+                  Pubid::INPUT_NOT_A_STRING_MESSAGE
+          end
+
+          if identifier.length > Pubid::MAX_INPUT_LENGTH
+            raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+          end
+
+          identifier = ::Pubid.utf8_input(identifier)
+
+          parsed = Pubid::Parg::Model.bound(:etsi_pfs, identifier)
+          Builder.build(parsed)
+        end
+      end
+    end
+  end

data/lib/pubid/etsi_pfs/identifiers/standard.rb

@@ -0,0 +1,22 @@
+  module Pubid
+    module EtsiPfs
+      module Identifiers
+        # Concrete ETSI Standard identifier type (PFS type `standard`).
+        class Standard < Identifier
+          TYPED_STAGES = [].freeze
+
+          def self.type
+            { key: :etsi, web: :etsi, title: "ETSI Standard", short: "ETSI" }
+          end
+
+          # The scheme-canonical wire tag declared in the definition:
+          # to_hash stays byte-identical with the scheme's coded
+          # flavor, and this flavor's own from_hash routes the tag
+          # to this class.
+          def self.polymorphic_name
+            "pubid:etsi:etsi-standard"
+          end
+        end
+      end
+    end
+  end

data/lib/pubid/etsi_pfs/identifiers.rb

@@ -0,0 +1,7 @@
+module Pubid
+  module EtsiPfs
+    module Identifiers
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+    end
+  end
+end

data/lib/pubid/etsi_pfs/parser.rb

@@ -0,0 +1,10 @@
+module Pubid
+  module EtsiPfs
+    # PFS-generated parser shell. Parsing runs through the baked
+    # PARG artifact (data/parg/etsi_pfs.json) via Pubid::Parg::Model.bound;
+    # the grammar source lives in pubid-grammar
+    # (grammars/etsi_pfs.parg, compiled from definitions/etsi.pfs).
+    class Parser
+    end
+  end
+end

data/lib/pubid/etsi_pfs/pubid_urn_schema.rb

@@ -0,0 +1,19 @@
+  module Pubid
+    module EtsiPfs
+      # The pubid-scheme URN schema, registered under the compiled
+      # flavor key. The definition's declared namespace
+      # ("etsi") is the scheme's canonical
+      # namespace; identifiers carry the scheme's wire tag, so their
+      # pubid URNs encode through the scheme's own schema.
+      PubidUrnSchema = Pubid::PubidUrn.define("etsi_pfs") do
+        atom "type", "type"
+        atom "parts", "part"
+        atom "minor", "minor"
+        atom "year", "year"
+        atom "month", "month"
+        atom "version", "v"
+        type "pubid:etsi_pfs:identifier", "id", core: []
+        type "pubid:etsi_pfs:standard", "es", core: []
+      end
+    end
+  end

data/lib/pubid/etsi_pfs/renderer.rb

@@ -0,0 +1,10 @@
+module Pubid
+  module EtsiPfs
+    # Human renderer, generated from the canonical template.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        "ETSI #{@id.type} #{@id.number}"
+      end
+    end
+  end
+end

data/lib/pubid/etsi_pfs/urn_generator.rb

@@ -0,0 +1,12 @@
+module Pubid
+  module EtsiPfs
+    # The official URN generator, pinned to the scheme's declared
+    # namespace ("etsi") so to_urn stays
+    # scheme-canonical under the compiled flavor key.
+    class UrnGenerator < ::Pubid::UrnGenerator::Base
+      def urn_namespace
+        "etsi"
+      end
+    end
+  end
+end

data/lib/pubid/etsi_pfs.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+#
+# PFS-generated flavor — DO NOT EDIT BY HAND.
+# Source: definitions/etsi.pfs (pfs:1) sha256:9343088bf087b55ea790057e6be0bbebe2272407ee81f035b52e5f9a4d5c7b76
+# Compiler: pubid/grammar/pfs 0.1.0 (baked with parsanol 1.3.126)
+# Regenerate: ruby scripts/pfs compile definitions/etsi.pfs --as etsi_pfs --ruby-out <dir>
+
+require "pubid"
+
+module Pubid
+  # ETSI flavor, compiled from its PFS definition
+  # (pubid/pubid#706). A compiled flavor is a peer of the coded
+  # flavors: same registry, same input guards, same error
+  # namespace, same URN contracts.
+  module EtsiPfs
+    extend Pubid::PrefixesSupport
+
+    PREFIXES = ["ETSI"].freeze
+
+    autoload :Builder, "#{__dir__}/etsi_pfs/builder"
+    autoload :Identifier, "#{__dir__}/etsi_pfs/identifier"
+    autoload :Identifiers, "#{__dir__}/etsi_pfs/identifiers"
+    autoload :Parser, "#{__dir__}/etsi_pfs/parser"
+    autoload :Renderer, "#{__dir__}/etsi_pfs/renderer"
+    autoload :PubidUrnSchema, "#{__dir__}/etsi_pfs/pubid_urn_schema"
+    autoload :UrnGenerator, "#{__dir__}/etsi_pfs/urn_generator"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: EtsiPfs::Renderer)
+
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
+      end
+    end
+
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+Pubid::Registry.register(:etsi_pfs, Pubid::EtsiPfs)

data/lib/pubid/itu/CLAUDE.md

@@ -82,20 +82,31 @@ a replay of all 24,382 rows and every ITU pass fixture showed 0 changes.
   code, so `#number` returns the series and `root.number` is `"RR"`. The rule
   ends in `any.absent?`: it sits before `with_series`, and PEG never re-enters
   the alternation, so a partial match on `ITU-R RR.1` must fail inside it.
-- **Operational Bulletins keep their sector.** This reverses the old
-  "cross-bureau, sector must not be set" rule: `validate_ob_no_sector!` is
-  gone, `ITU-T OB.1096 (2016)` renders back as it is, and the sector-less
-  `ITU OB No. 1096` is unchanged. The long forms with a sector (`ITU-T OB No.
-  1096`) now normalise to `ITU-T OB.1096`. `No.` stays in the default
-  render — it is how ITU's bulletin site and pubid v1 write it — and
-  metanorma-itu's `ITU OB 1000` / `Annex to ITU OB 1000` (its i18n template
-  omits `No.`) is accepted on parse (`ob_bare_body`) and rendered with it.
-  The sector is a spelling, not
-  identity: `SpecialPublication#==` skips it, the URN keeps `urn:itu:itu:…`
-  and `mr_type` stays nil, so both spellings are one bulletin on every
-  surface except `to_s`/`to_hash`. The printed date `- 15.III.2016` sets
-  `date.day`, which only this form does, so `render_ob_date` uses the day as
-  the spelling marker; `day_to_kv` emits only then.
+- **An Operational Bulletin never carries a sector (#696).** OB is an
+  org-level publication: "ITU OB", never "ITU-T OB". This reverses the
+  "Operational Bulletins keep their sector" rule of `27454393`, which kept the
+  sector as a spelling but left it in `to_hash`, so `ITU OB No. 1096` and
+  `ITU-T OB.1096` were `==` and had two pubid-scheme URNs (two relaton slugs).
+  The TSB spellings (`ITU-T OB.1096`, `ITU-T OB No. 1096`, `ITU-T Operational
+  Bulletin No. 1096`, also as an `Annex to …` base) still **parse** — the
+  grammar is unchanged — but `build_special_publication` passes no sector and
+  `SpecialPublication` drops one given to `new` or to `sector=` (the path a
+  legacy `from_hash` row with `"sector" => "T"` takes). So every surface,
+  `to_s` included, is sector-free: `ITU-T OB.1096 (2016)` renders `ITU OB
+  No. 1096 (2016)`. The `ITU-T OB…` lines in `pass/special_publication.txt`
+  are therefore `!input!rendered`. `No.` stays in the default render — it is
+  how ITU's bulletin site and pubid v1 write it — and metanorma-itu's `ITU OB
+  1000` / `Annex to ITU OB 1000` (its i18n template omits `No.`) is accepted
+  on parse (`ob_bare_body`) and rendered with it. The printed date
+  `- 15.III.2016` sets `date.day`, which only this form does, so
+  `render_ob_date` uses the day as the spelling marker; `day_to_kv` emits only
+  then. `build_supplement` does not take the sector of a TSB-spelled OB base
+  either, so `ITU-T OB.1096 Amd. 1` stores no sector and slugs
+  `itu.ob-1096…`. **Known gap:** the grammar has no sector-less OB
+  supplement, so that id renders `ITU OB No. 1096 Amd. 1`, which does not
+  parse back. No corpus holds an OB supplement; a grammar rule would be a
+  pubid-grammar change. Sources that cite `ITU-T OB` (relaton's
+  `publication_code`, the pubid-testsuite rows) are fixed in their own repos.
 - **`-YYYYMM` is a date, never a part.** `part` refuses a six-digit run with a
   19xx/20xx year and a 01–12 month (`yyyymm_shape`), and `id_date` reads it as
   year+month. `-200313`, `-180001` stay parts. `ITU-T REC T.4` drops the

data/lib/pubid/itu/builder.rb

@@ -170,12 +170,10 @@ module Pubid
         nil
       end
 
-      # Build Special Publication (OB). The sector of the TSB spelling
-      # ("ITU-T OB.1096") is kept so the bulletin renders back as it was cited;
-      # SpecialPublication#== ignores it, since OB is cross-bureau.
+      # Build Special Publication (OB). An OB never carries a sector, so the
+      # sector of the TSB spelling ("ITU-T OB.1096") is discarded (#696).
       def build_special_publication(data)
         Identifiers::SpecialPublication.new(
-          sector: (Components::Sector.new(sector: data[:sector].to_s) if data[:sector]),
           series: Components::Series.new(series: "OB"),
           code: data[:number] ? build_code(data) : nil,
           date: data[:year] ? build_date(data) : nil,
@@ -289,8 +287,12 @@ module Pubid
         # it via #root; otherwise a supplement of an annex would carry none of
         # them and its MR string would collapse to a bare "itu.<date>".
         base_identity = base&.sector ? base : base&.root
+        # An Operational Bulletin never carries a sector (#696), so a
+        # supplement of one does not take the sector of its TSB spelling.
+        own_sector = data[:sector] &&
+          !base_identity.is_a?(Identifiers::SpecialPublication)
         sector = base_identity&.sector ||
-          (Components::Sector.new(sector: data[:sector].to_s) if data[:sector])
+          (Components::Sector.new(sector: data[:sector].to_s) if own_sector)
         series = base_identity&.series ||
           (Components::Series.new(series: data[:series].to_s) if data[:series])
 

data/lib/pubid/itu/identifiers/special_publication.rb

@@ -4,29 +4,33 @@ module Pubid
   module Itu
     module Identifiers
       # ITU Special Publication — currently models the Operational Bulletin (OB).
-      # OB is a cross-bureau publication. ITU prints it without a sector
-      # ("ITU OB No. 1283 (01/2024)"); the TSB spelling carries one
-      # ("ITU-T OB.1096 (2016)"), which is kept and rendered back. The sector
-      # is not part of the identity: `==`, the URN and the MR slug ignore it,
-      # so both spellings name one bulletin.
+      # OB is an org-level publication: it never carries a sector
+      # ("ITU OB No. 1283 (01/2024)", never "ITU-T OB"). The TSB spelling
+      # ("ITU-T OB.1096 (2016)") parses, but the sector is discarded here, so
+      # both spellings are one value on every surface — `to_s`, `to_hash`,
+      # `==`, the URN and the pubid-scheme URN (issue #696).
       class SpecialPublication < Identifier
         include StandardSerialization
 
         ROMAN_MONTHS = %w[I II III IV V VI VII VIII IX X XI XII].freeze
 
-        def render_base(**_opts)
-          number = code&.number
-          result = if sector
-                     "#{publisher}-#{sector} #{series}.#{number}"
-                   else
-                     "#{publisher} #{series} No. #{number}"
-                   end
+        # Drop a sector given on construction (the parse path never passes
+        # one; a caller or a legacy hash row may).
+        def initialize(**kwargs)
+          super(**kwargs.except(:sector))
+        end
 
-          result + render_ob_date
+        # Drop a sector set later — `from_hash` of a legacy row with
+        # `"sector" => "T"` comes through this setter.
+        def sector=(_value)
+          super(nil)
+        end
+
+        def render_base(**_opts)
+          "#{publisher} #{series} No. #{code&.number}#{render_ob_date}"
         end
 
-        # Cross-bureau: the sector is how one bureau cites the bulletin, not
-        # which bulletin it is.
+        # Only the fields a bulletin carries. The sector is always nil now.
         def ==(other)
           return false unless other.instance_of?(self.class)
 
@@ -37,8 +41,7 @@ module Pubid
             common_text_twin == other.common_text_twin
         end
 
-        # Keep the MR slug sector-free, like `==` (it was always so, because
-        # the sector used to be dropped).
+        # A bulletin has no type token in its MR slug.
         def mr_type
           nil
         end

data/lib/pubid/itu/urn_generator.rb

@@ -16,10 +16,9 @@ module Pubid
       def generate_base_urn
         parts = ["urn", "itu"]
 
-        # An Operational Bulletin is cross-bureau: its sector is a spelling,
-        # not identity (see SpecialPublication#==), so it stays out of the URN.
-        if identifier.sector &&
-            !identifier.is_a?(Identifiers::SpecialPublication)
+        # An Operational Bulletin never carries a sector (#696), so it gets
+        # the `itu` segment here.
+        if identifier.sector
           sector = identifier.sector.to_s
           parts << sector.to_s.downcase
         else

data/lib/pubid/jis/CLAUDE.md

@@ -29,6 +29,41 @@
   `UrnParser` does not prepend `JIS ` to a code that starts with `WES `.
 - `PREFIXES` includes `"WES"`, so `Pubid.parse("WES …")` routes to JIS.
 
+## WES `(E)` before the year, `WES TR`, `WES TS` (relaton-jis#18)
+
+- JSA Webdesk lists 14 WES ids that the grammar does not read:
+  `WES 1112(E):2022`, `WES TR 2032:2024`, `WES TS 2816(E):2015`.
+- **A Ruby shim reads them, not the grammar.** `Parser.ingest` cuts
+  the `TR`/`TS` token and a `(E)`/`(J)` that comes before `:year`, and
+  binds them as `wes_type` and `wes_language`. Other input passes unchanged.
+  The hand-off `pubid__pubid-grammar__jis-wes-language-tr-ts` asks
+  pubid-grammar to bind the same two captures. After that lands, re-vendor
+  `jis.json`, re-pin `parg_reaffirmed_spec.rb`, and delete the shim. The
+  builder does not change.
+- **`WES TR`/`WES TS` are classes**: `WeldingEngineeringTechnicalReport`
+  and `…TechnicalSpecification` < `WeldingEngineeringStandard`, with
+  `WES_TYPE` in `code` (`WES TR 2032`) and in `mr_type`. Class-strict `==`
+  keeps them apart from `WES 2032` and `JIS TR Z 2032`.
+- **`language_before_year`** records where the source put the language. It
+  is spelling only (`equality_ignored`, a `langfirst` facet in the pubid
+  URN): `WES 1112(E):2022 == WES 1112:2022(E)`, and each renders as written.
+  The language itself is identity, so the `(E)` edition is not the Japanese
+  one. JIS ids never set the flag; `JIS X 0208(E):1997` still fails.
+- The pubid URN schema now places `language` and the supplement ordinal
+  (`core: [["number", :int]]`; an `EXPL` number is the atom `n`). Before,
+  every `(E)` id and every supplement raised in `to_pubid_urn`, and no
+  supplement was in the fixture corpus to show it.
+- **`Builder` reads both parse shapes.** The typed bindings
+  (`Parg::Model.bound`) carry a supplement flat (`amd_type`, …); the raw
+  tree (`Parg::Backend.parse`) nests it under `:amendment`/`:explanation`/
+  `:corrigendum`. `flatten_supplement` folds the nested form. Before, the
+  tree path dropped every supplement silently (`…/AMD 1:2000` built as the
+  bare base). `typed_binding_parity_spec.rb` found it when the first
+  supplement entered the pass corpus.
+- **The shim lives in `Parser.ingest`** and returns `[face, bindings]`.
+  `typed_binding_parity_spec.rb` calls it on the tree path too and merges
+  the bindings, as `Identifier.parse` does.
+
 ## Equality includes the class
 
 - `Identifier#==` requires `other.instance_of?(self.class)`: `JIS TR X